diff --git a/bin/hbase b/bin/hbase index 559a02e9f8c0..59a3b6915321 100755 --- a/bin/hbase +++ b/bin/hbase @@ -92,7 +92,8 @@ if [ $# = 0 ]; then echo "Commands:" echo "Some commands take arguments. Pass no args or -h for usage." echo " shell Run the HBase shell" - echo " hbck Run the hbase 'fsck' tool" + echo " hbck Run the HBase 'fsck' tool. Defaults read-only hbck1." + echo " Pass '-j /path/to/HBCK2.jar' to run hbase-2.x HBCK2." echo " snapshot Tool for managing snapshots" if [ "${in_omnibus_tarball}" = "true" ]; then echo " wal Write-ahead-log analyzer" @@ -482,7 +483,25 @@ if [ "$COMMAND" = "shell" ] ; then HBASE_OPTS="$HBASE_OPTS $HBASE_SHELL_OPTS" CLASS="org.jruby.Main -X+O ${JRUBY_OPTS} ${HBASE_HOME}/bin/hirb.rb" elif [ "$COMMAND" = "hbck" ] ; then - CLASS='org.apache.hadoop.hbase.util.HBaseFsck' + # Look for the -j /path/to/HBCK2.jar parameter. Else pass through to hbck. + case "${1}" in + -j) + # Found -j parameter. Add arg to CLASSPATH and set CLASS to HBCK2. + shift + JAR="${1}" + if [ ! -f "${JAR}" ]; then + echo "${JAR} file not found!" + echo "Usage: hbase [] hbck -jar /path/to/HBCK2.jar []" + exit 1 + fi + CLASSPATH="${JAR}:${CLASSPATH}"; + CLASS="org.apache.hbase.HBCK2" + shift # past argument=value + ;; + *) + CLASS='org.apache.hadoop.hbase.util.HBaseFsck' + ;; + esac elif [ "$COMMAND" = "wal" ] ; then CLASS='org.apache.hadoop.hbase.wal.WALPrettyPrinter' elif [ "$COMMAND" = "hfile" ] ; then diff --git a/dev-support/Jenkinsfile b/dev-support/Jenkinsfile index bbff87cc0c91..b333afbd7f28 100644 --- a/dev-support/Jenkinsfile +++ b/dev-support/Jenkinsfile @@ -80,7 +80,8 @@ pipeline { if [[ true != "${USE_YETUS_PRERELEASE}" ]]; then YETUS_DIR="${WORKSPACE}/yetus-${YETUS_RELEASE}" echo "Checking for Yetus ${YETUS_RELEASE} in '${YETUS_DIR}'" - if [ ! -d "${YETUS_DIR}" ]; then + if ! "${YETUS_DIR}/bin/test-patch" --version >/dev/null 2>&1 ; then + rm -rf "${YETUS_DIR}" "${WORKSPACE}/component/dev-support/jenkins-scripts/cache-apache-project-artifact.sh" \ --working-dir "${WORKSPACE}/downloads-yetus" \ --keys 'https://www.apache.org/dist/yetus/KEYS' \ diff --git a/dev-support/submit-patch.py b/dev-support/submit-patch.py index f5d772fb3b6b..56955852f0e3 100755 --- a/dev-support/submit-patch.py +++ b/dev-support/submit-patch.py @@ -171,17 +171,16 @@ def validate_patch_dir(patch_dir): # - current branch is same as base branch # - current branch is ahead of base_branch by more than 1 commits def check_diff_between_branches(base_branch): - only_in_base_branch = git.log("HEAD.." + base_branch, oneline = True) - only_in_active_branch = git.log(base_branch + "..HEAD", oneline = True) + only_in_base_branch = list(repo.iter_commits("HEAD.." + base_branch)) + only_in_active_branch = list(repo.iter_commits(base_branch + "..HEAD")) if len(only_in_base_branch) != 0: log_fatal_and_exit(" '%s' is ahead of current branch by %s commits. Rebase " - "and try again.", base_branch, len(only_in_base_branch.split("\n"))) + "and try again.", base_branch, len(only_in_base_branch)) if len(only_in_active_branch) == 0: log_fatal_and_exit(" Current branch is same as '%s'. Exiting...", base_branch) - if len(only_in_active_branch.split("\n")) > 1: + if len(only_in_active_branch) > 1: log_fatal_and_exit(" Current branch is ahead of '%s' by %s commits. Squash into single " - "commit and try again.", - base_branch, len(only_in_active_branch.split("\n"))) + "commit and try again.", base_branch, len(only_in_active_branch)) # If ~/.apache-creds is present, load credentials from it otherwise prompt user. @@ -277,7 +276,7 @@ def get_review_board_id_if_present(issue_url, rb_link_title): # Use jira summary as review's summary too. summary = get_jira_summary(issue_url) # Use commit message as description. - description = git.log("-1", pretty="%B") + description = repo.head.commit.message update_draft_data = {"bugs_closed" : [args.jira_id.upper()], "target_groups" : "hbase", "target_people" : args.reviewers, "summary" : summary, "description" : description } diff --git a/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/impl/IncrementalBackupManager.java b/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/impl/IncrementalBackupManager.java index 3eebf4299c36..853f458456d0 100644 --- a/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/impl/IncrementalBackupManager.java +++ b/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/impl/IncrementalBackupManager.java @@ -296,9 +296,20 @@ private List getLogFilesForNewBackup(HashMap olderTimestam currentLogFile = log.getPath().toString(); resultLogFiles.add(currentLogFile); currentLogTS = BackupUtils.getCreationTime(log.getPath()); - // newestTimestamps is up-to-date with the current list of hosts - // so newestTimestamps.get(host) will not be null. - if (currentLogTS > newestTimestamps.get(host)) { + + // If newestTimestamps.get(host) is null, means that + // either RS (host) has been restarted recently with different port number + // or RS is down (was decommisioned). In any case, we treat this + // log file as eligible for inclusion into incremental backup log list + Long ts = newestTimestamps.get(host); + if (ts == null) { + LOG.warn("ORPHAN log found: " + log + " host=" + host); + LOG.debug("Known hosts (from newestTimestamps):"); + for (String s: newestTimestamps.keySet()) { + LOG.debug(s); + } + } + if (ts == null || currentLogTS > ts) { newestLogs.add(currentLogFile); } } @@ -343,7 +354,7 @@ private List getLogFilesForNewBackup(HashMap olderTimestam // Even if these logs belong to a obsolete region server, we still need // to include they to avoid loss of edits for backup. Long newTimestamp = newestTimestamps.get(host); - if (newTimestamp != null && currentLogTS > newTimestamp) { + if (newTimestamp == null || currentLogTS > newTimestamp) { newestLogs.add(currentLogFile); } } diff --git a/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/MapReduceHFileSplitterJob.java b/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/MapReduceHFileSplitterJob.java index 1a3c46528a48..b8d520c530c7 100644 --- a/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/MapReduceHFileSplitterJob.java +++ b/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/mapreduce/MapReduceHFileSplitterJob.java @@ -164,7 +164,7 @@ public static void main(String[] args) throws Exception { public int run(String[] args) throws Exception { if (args.length < 2) { usage("Wrong number of arguments: " + args.length); - System.exit(-1); + return -1; } Job job = createSubmittableJob(args); int result = job.waitForCompletion(true) ? 0 : 1; diff --git a/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/util/BackupUtils.java b/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/util/BackupUtils.java index 12f2f2f846bc..da11756fe024 100644 --- a/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/util/BackupUtils.java +++ b/hbase-backup/src/main/java/org/apache/hadoop/hbase/backup/util/BackupUtils.java @@ -327,7 +327,7 @@ public static void checkTargetDir(String backupRootPath, Configuration conf) thr if (expMsg.contains("No FileSystem for scheme")) { newMsg = "Unsupported filesystem scheme found in the backup target url. Error Message: " - + newMsg; + + expMsg; LOG.error(newMsg); throw new IOException(newMsg); } else { diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java index a43a0b2dc0fa..08b44c930152 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Admin.java @@ -1737,11 +1737,14 @@ HTableDescriptor[] getTableDescriptors(List names) /** * Abort a procedure. + * Do not use. Usually it is ignored but if not, it can do more damage than good. See hbck2. * @param procId ID of the procedure to abort * @param mayInterruptIfRunning if the proc completed at least one step, should it be aborted? * @return true if aborted, false if procedure already completed or does not exist * @throws IOException + * @deprecated Since 2.1.1 -- to be removed. */ + @Deprecated boolean abortProcedure( long procId, boolean mayInterruptIfRunning) throws IOException; @@ -1752,12 +1755,15 @@ boolean abortProcedure( * It may throw ExecutionException if there was an error while executing the operation * or TimeoutException in case the wait timeout was not long enough to allow the * operation to complete. + * Do not use. Usually it is ignored but if not, it can do more damage than good. See hbck2. * * @param procId ID of the procedure to abort * @param mayInterruptIfRunning if the proc completed at least one step, should it be aborted? * @return true if aborted, false if procedure already completed or does not exist * @throws IOException + * @deprecated Since 2.1.1 -- to be removed. */ + @Deprecated Future abortProcedureAsync( long procId, boolean mayInterruptIfRunning) throws IOException; diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java index 739c78a46ddc..6bb253a20abd 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncAdmin.java @@ -877,12 +877,15 @@ CompletableFuture isProcedureFinished(String signature, String instance Map props); /** - * abort a procedure + * Abort a procedure + * Do not use. Usually it is ignored but if not, it can do more damage than good. See hbck2. * @param procId ID of the procedure to abort * @param mayInterruptIfRunning if the proc completed at least one step, should it be aborted? * @return true if aborted, false if procedure already completed or does not exist. the value is * wrapped by {@link CompletableFuture} + * @deprecated Since 2.1.1 -- to be removed. */ + @Deprecated CompletableFuture abortProcedure(long procId, boolean mayInterruptIfRunning); /** diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRequestFutureImpl.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRequestFutureImpl.java index 80535a1691e4..b75b0c60bf06 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRequestFutureImpl.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncRequestFutureImpl.java @@ -826,7 +826,9 @@ private void receiveMultiAction(MultiAction multiAction, byte[] regionName = regionEntry.getKey(); Throwable regionException = responses.getExceptions().get(regionName); - cleanServerCache(server, regionException); + if (regionException != null) { + cleanServerCache(server, regionException); + } Map regionResults = results.containsKey(regionName) ? results.get(regionName).result : Collections.emptyMap(); diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java index c54ff1750b17..45961ff4886e 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java @@ -25,6 +25,7 @@ import java.io.InterruptedIOException; import java.util.ArrayList; import java.util.Arrays; +import java.util.Collections; import java.util.EnumSet; import java.util.HashMap; import java.util.Iterator; @@ -230,7 +231,6 @@ * @see Admin */ @InterfaceAudience.Private -@InterfaceStability.Evolving public class HBaseAdmin implements Admin { private static final Logger LOG = LoggerFactory.getLogger(HBaseAdmin.class); @@ -4314,15 +4314,13 @@ public Void call() throws Exception { } @Override - public List clearDeadServers(final List servers) throws IOException { - if (servers == null || servers.size() == 0) { - throw new IllegalArgumentException("servers cannot be null or empty"); - } + public List clearDeadServers(List servers) throws IOException { return executeCallable(new MasterCallable>(getConnection(), getRpcControllerFactory()) { @Override protected List rpcCall() throws Exception { - ClearDeadServersRequest req = RequestConverter.buildClearDeadServersRequest(servers); + ClearDeadServersRequest req = RequestConverter. + buildClearDeadServersRequest(servers == null? Collections.EMPTY_LIST: servers); return ProtobufUtil.toServerNameList( master.clearDeadServers(getRpcController(), req).getServerNameList()); } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseHbck.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseHbck.java index 03a6f69c2218..2d088253a4bc 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseHbck.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseHbck.java @@ -18,25 +18,38 @@ package org.apache.hadoop.hbase.client; import java.io.IOException; +import java.util.List; +import java.util.concurrent.Callable; +import java.util.stream.Collectors; + import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.ipc.RpcControllerFactory; -import org.apache.yetus.audience.InterfaceAudience; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; -import org.apache.hbase.thirdparty.com.google.protobuf.ServiceException; +import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.RequestConverter; +import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.GetTableStateResponse; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.HbckService.BlockingInterface; +import org.apache.hbase.thirdparty.com.google.protobuf.ServiceException; + +import org.apache.yetus.audience.InterfaceAudience; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + /** * Use {@link ClusterConnection#getHbck()} to obtain an instance of {@link Hbck} instead of - * constructing - * an HBaseHbck directly. This will be mostly used by hbck tool. + * constructing an HBaseHbck directly. * *

Connection should be an unmanaged connection obtained via * {@link ConnectionFactory#createConnection(Configuration)}.

* + *

NOTE: The methods in here can do damage to a cluster if applied in the wrong sequence or at + * the wrong time. Use with caution. For experts only. These methods are only for the + * extreme case where the cluster has been damaged or has achieved an inconsistent state because + * of some unforeseen circumstance or bug and requires manual intervention. + * *

An instance of this class is lightweight and not-thread safe. A new instance should be created * by each thread. Pooling or caching of the instance is not recommended.

* @@ -75,10 +88,6 @@ public boolean isAborted() { return this.aborted; } - /** - * NOTE: This is a dangerous action, as existing running procedures for the table or regions - * which belong to the table may get confused. - */ @Override public TableState setTableStateInMeta(TableState state) throws IOException { try { @@ -87,9 +96,62 @@ public TableState setTableStateInMeta(TableState state) throws IOException { RequestConverter.buildSetTableStateInMetaRequest(state)); return TableState.convert(state.getTableName(), response.getTableState()); } catch (ServiceException se) { - LOG.debug("ServiceException while updating table state in meta. table={}, state={}", - state.getTableName(), state.getState()); + LOG.debug("table={}, state={}", state.getTableName(), state.getState(), se); + throw new IOException(se); + } + } + + @Override + public List assigns(List encodedRegionNames, boolean override) + throws IOException { + try { + MasterProtos.AssignsResponse response = + this.hbck.assigns(rpcControllerFactory.newController(), + RequestConverter.toAssignRegionsRequest(encodedRegionNames, override)); + return response.getPidList(); + } catch (ServiceException se) { + LOG.debug(toCommaDelimitedString(encodedRegionNames), se); + throw new IOException(se); + } + } + + @Override + public List unassigns(List encodedRegionNames, boolean override) + throws IOException { + try { + MasterProtos.UnassignsResponse response = + this.hbck.unassigns(rpcControllerFactory.newController(), + RequestConverter.toUnassignRegionsRequest(encodedRegionNames, override)); + return response.getPidList(); + } catch (ServiceException se) { + LOG.debug(toCommaDelimitedString(encodedRegionNames), se); throw new IOException(se); } } + + private static String toCommaDelimitedString(List list) { + return list.stream().collect(Collectors.joining(", ")); + } + + @Override + public List bypassProcedure(List pids, long waitTime, boolean override, + boolean recursive) + throws IOException { + MasterProtos.BypassProcedureResponse response = ProtobufUtil.call( + new Callable() { + @Override + public MasterProtos.BypassProcedureResponse call() throws Exception { + try { + return hbck.bypassProcedure(rpcControllerFactory.newController(), + MasterProtos.BypassProcedureRequest.newBuilder().addAllProcId(pids). + setWaitTime(waitTime).setOverride(override).setRecursive(recursive).build()); + } catch (Throwable t) { + LOG.error(pids.stream().map(i -> i.toString()). + collect(Collectors.joining(", ")), t); + throw t; + } + } + }); + return response.getBypassedList(); + } } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java index 69ec3661c5a6..fb69a2530bf5 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java @@ -487,35 +487,20 @@ public static void doBatchWithCallback(List actions, Object[] } @Override - public void delete(final Delete delete) - throws IOException { - CancellableRegionServerCallable callable = - new CancellableRegionServerCallable( - connection, getName(), delete.getRow(), this.rpcControllerFactory.newController(), - writeRpcTimeoutMs, new RetryingTimeTracker().start(), delete.getPriority()) { + public void delete(final Delete delete) throws IOException { + ClientServiceCallable callable = + new ClientServiceCallable(this.connection, getName(), delete.getRow(), + this.rpcControllerFactory.newController(), delete.getPriority()) { @Override - protected SingleResponse rpcCall() throws Exception { - MutateRequest request = RequestConverter.buildMutateRequest( - getLocation().getRegionInfo().getRegionName(), delete); - MutateResponse response = doMutate(request); - return ResponseConverter.getResult(request, response, getRpcControllerCellScanner()); + protected Void rpcCall() throws Exception { + MutateRequest request = RequestConverter + .buildMutateRequest(getLocation().getRegionInfo().getRegionName(), delete); + doMutate(request); + return null; } }; - List rows = Collections.singletonList(delete); - AsyncProcessTask task = AsyncProcessTask.newBuilder() - .setPool(pool) - .setTableName(tableName) - .setRowAccess(rows) - .setCallable(callable) - .setRpcTimeout(writeRpcTimeoutMs) - .setOperationTimeout(operationTimeoutMs) - .setSubmittedRows(AsyncProcessTask.SubmittedRows.ALL) - .build(); - AsyncRequestFuture ars = multiAp.submit(task); - ars.waitUntilDone(); - if (ars.hasError()) { - throw ars.getErrors(); - } + rpcCallerFactory.newCaller(this.writeRpcTimeoutMs) + .callWithRetries(callable, this.operationTimeoutMs); } @Override diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Hbck.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Hbck.java index a216cdbc6b7d..5c97d97daabd 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Hbck.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/client/Hbck.java @@ -19,32 +19,86 @@ import java.io.Closeable; import java.io.IOException; +import java.util.List; + import org.apache.hadoop.hbase.Abortable; import org.apache.hadoop.hbase.HBaseInterfaceAudience; import org.apache.yetus.audience.InterfaceAudience; /** - * Hbck APIs for HBase. Obtain an instance from {@link ClusterConnection#getHbck()} and call + * Hbck fixup tool APIs. Obtain an instance from {@link ClusterConnection#getHbck()} and call * {@link #close()} when done. - *

Hbck client APIs will be mostly used by hbck tool which in turn can be used by operators to - * fix HBase and bringging it to consistent state.

+ *

WARNING: the below methods can damage the cluster. It may leave the cluster in an + * indeterminate state, e.g. region not assigned, or some hdfs files left behind. After running + * any of the below, operators may have to do some clean up on hdfs or schedule some assign + * procedures to get regions back online. DO AT YOUR OWN RISK. For experienced users only. * * @see ConnectionFactory * @see ClusterConnection - * @since 2.2.0 + * @since 2.0.2, 2.1.1 */ @InterfaceAudience.LimitedPrivate(HBaseInterfaceAudience.HBCK) public interface Hbck extends Abortable, Closeable { /** - * Update table state in Meta only. No procedures are submitted to open/ assign or close/ - * unassign regions of the table. This is useful only when some procedures/ actions are stuck - * beause of inconsistency between region and table states. - * - * NOTE: This is a dangerous action, as existing running procedures for the table or regions - * which belong to the table may get confused. - * + * Update table state in Meta only. No procedures are submitted to open/assign or + * close/unassign regions of the table. * @param state table state * @return previous state of the table in Meta */ TableState setTableStateInMeta(TableState state) throws IOException; + + /** + * Like {@link Admin#assign(byte[])} but 'raw' in that it can do more than one Region at a time + * -- good if many Regions to online -- and it will schedule the assigns even in the case where + * Master is initializing (as long as the ProcedureExecutor is up). Does NOT call Coprocessor + * hooks. + * @param override You need to add the override for case where a region has previously been + * bypassed. When a Procedure has been bypassed, a Procedure will have completed + * but no other Procedure will be able to make progress on the target entity + * (intentionally). This override flag will override this fencing mechanism. + * @param encodedRegionNames Region encoded names; e.g. 1588230740 is the hard-coded encoding + * for hbase:meta region and de00010733901a05f5a2a3a382e27dd4 is an + * example of what a random user-space encoded Region name looks like. + */ + List assigns(List encodedRegionNames, boolean override) throws IOException; + + default List assigns(List encodedRegionNames) throws IOException { + return assigns(encodedRegionNames, false); + } + + /** + * Like {@link Admin#unassign(byte[], boolean)} but 'raw' in that it can do more than one Region + * at a time -- good if many Regions to offline -- and it will schedule the assigns even in the + * case where Master is initializing (as long as the ProcedureExecutor is up). Does NOT call + * Coprocessor hooks. + * @param override You need to add the override for case where a region has previously been + * bypassed. When a Procedure has been bypassed, a Procedure will have completed + * but no other Procedure will be able to make progress on the target entity + * (intentionally). This override flag will override this fencing mechanism. + * @param encodedRegionNames Region encoded names; e.g. 1588230740 is the hard-coded encoding + * for hbase:meta region and de00010733901a05f5a2a3a382e27dd4 is an + * example of what a random user-space encoded Region name looks like. + */ + List unassigns(List encodedRegionNames, boolean override) throws IOException; + + default List unassigns(List encodedRegionNames) throws IOException { + return unassigns(encodedRegionNames, false); + } + + /** + * Bypass specified procedure and move it to completion. Procedure is marked completed but + * no actual work is done from the current state/step onwards. Parents of the procedure are + * also marked for bypass. + * + * @param pids of procedures to complete. + * @param waitTime wait time in ms for acquiring lock for a procedure + * @param override if override set to true, we will bypass the procedure even if it is executing. + * This is for procedures which can't break out during execution (bugs?). + * @param recursive If set, if a parent procedure, we will find and bypass children and then + * the parent procedure (Dangerous but useful in case where child procedure has been 'lost'). + * Does not always work. Experimental. + * @return true if procedure is marked for bypass successfully, false otherwise + */ + List bypassProcedure(List pids, long waitTime, boolean override, boolean recursive) + throws IOException; } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/filter/FuzzyRowFilter.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/filter/FuzzyRowFilter.java index d1acbba9811a..abfa7e1d6e8c 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/filter/FuzzyRowFilter.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/filter/FuzzyRowFilter.java @@ -35,7 +35,6 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos.BytesBytesPair; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.Pair; -import org.apache.hadoop.hbase.util.UnsafeAccess; import org.apache.hadoop.hbase.util.UnsafeAvailChecker; import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; @@ -352,9 +351,9 @@ static SatisfiesCode satisfies(boolean reverse, byte[] row, int offset, int leng int j = numWords << 3; // numWords * SIZEOF_LONG; for (int i = 0; i < j; i += Bytes.SIZEOF_LONG) { - long fuzzyBytes = UnsafeAccess.toLong(fuzzyKeyBytes, i); - long fuzzyMeta = UnsafeAccess.toLong(fuzzyKeyMeta, i); - long rowValue = UnsafeAccess.toLong(row, offset + i); + long fuzzyBytes = Bytes.toLong(fuzzyKeyBytes, i); + long fuzzyMeta = Bytes.toLong(fuzzyKeyMeta, i); + long rowValue = Bytes.toLong(row, offset + i); if ((rowValue & fuzzyMeta) != (fuzzyBytes)) { // We always return NEXT_EXISTS return SatisfiesCode.NEXT_EXISTS; @@ -364,9 +363,9 @@ static SatisfiesCode satisfies(boolean reverse, byte[] row, int offset, int leng int off = j; if (length - off >= Bytes.SIZEOF_INT) { - int fuzzyBytes = UnsafeAccess.toInt(fuzzyKeyBytes, off); - int fuzzyMeta = UnsafeAccess.toInt(fuzzyKeyMeta, off); - int rowValue = UnsafeAccess.toInt(row, offset + off); + int fuzzyBytes = Bytes.toInt(fuzzyKeyBytes, off); + int fuzzyMeta = Bytes.toInt(fuzzyKeyMeta, off); + int rowValue = Bytes.toInt(row, offset + off); if ((rowValue & fuzzyMeta) != (fuzzyBytes)) { // We always return NEXT_EXISTS return SatisfiesCode.NEXT_EXISTS; @@ -375,9 +374,9 @@ static SatisfiesCode satisfies(boolean reverse, byte[] row, int offset, int leng } if (length - off >= Bytes.SIZEOF_SHORT) { - short fuzzyBytes = UnsafeAccess.toShort(fuzzyKeyBytes, off); - short fuzzyMeta = UnsafeAccess.toShort(fuzzyKeyMeta, off); - short rowValue = UnsafeAccess.toShort(row, offset + off); + short fuzzyBytes = Bytes.toShort(fuzzyKeyBytes, off); + short fuzzyMeta = Bytes.toShort(fuzzyKeyMeta, off); + short rowValue = Bytes.toShort(row, offset + off); if ((rowValue & fuzzyMeta) != (fuzzyBytes)) { // We always return NEXT_EXISTS // even if it does not (in this case getNextForFuzzyRule diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/BloomType.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/BloomType.java index 778784232598..c0b2dd204126 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/BloomType.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/BloomType.java @@ -34,5 +34,13 @@ public enum BloomType { /** * Bloom enabled with Table row & column (family+qualifier) as Key */ - ROWCOL + ROWCOL, + /** + * Bloom enabled with Table row prefix as Key, specify the length of the prefix + */ + ROWPREFIX_FIXED_LENGTH, + /** + * Bloom enabled with Table row prefix as Key, specify the delimiter of the prefix + */ + ROWPREFIX_DELIMITED } diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/InvalidMutationDurabilityException.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/InvalidMutationDurabilityException.java new file mode 100644 index 000000000000..d694f3774f34 --- /dev/null +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/regionserver/InvalidMutationDurabilityException.java @@ -0,0 +1,44 @@ +/** + * + * 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.regionserver; + +import org.apache.hadoop.hbase.DoNotRetryIOException; +import org.apache.hadoop.hbase.client.Durability; +import org.apache.yetus.audience.InterfaceAudience; + +/** + * Thrown if Mutation's {@link Durability} is skip wal but table need replication. + */ +@InterfaceAudience.Public +public class InvalidMutationDurabilityException extends DoNotRetryIOException { + + /** + * default constructor + */ + public InvalidMutationDurabilityException() { + super(); + } + + /** + * @param message exception message + */ + public InvalidMutationDurabilityException(String message) { + super(message); + } +} diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/security/SecurityInfo.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/security/SecurityInfo.java index 8fca997fdc83..eb9d209be2fa 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/security/SecurityInfo.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/security/SecurityInfo.java @@ -20,12 +20,13 @@ import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; -import org.apache.yetus.audience.InterfaceAudience; -import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; import org.apache.hadoop.hbase.protobuf.generated.AuthenticationProtos.TokenIdentifier.Kind; +import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos; +import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos.MasterService; import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos; +import org.apache.yetus.audience.InterfaceAudience; /** * Maps RPC protocol interfaces to required configuration @@ -37,13 +38,19 @@ public class SecurityInfo { // populate info for known services static { infos.put(AdminProtos.AdminService.getDescriptor().getName(), - new SecurityInfo("hbase.regionserver.kerberos.principal", Kind.HBASE_AUTH_TOKEN)); + new SecurityInfo("hbase.regionserver.kerberos.principal", + Kind.HBASE_AUTH_TOKEN)); infos.put(ClientProtos.ClientService.getDescriptor().getName(), - new SecurityInfo("hbase.regionserver.kerberos.principal", Kind.HBASE_AUTH_TOKEN)); + new SecurityInfo("hbase.regionserver.kerberos.principal", + Kind.HBASE_AUTH_TOKEN)); infos.put(MasterService.getDescriptor().getName(), new SecurityInfo("hbase.master.kerberos.principal", Kind.HBASE_AUTH_TOKEN)); infos.put(RegionServerStatusProtos.RegionServerStatusService.getDescriptor().getName(), new SecurityInfo("hbase.master.kerberos.principal", Kind.HBASE_AUTH_TOKEN)); + infos.put(MasterProtos.HbckService.getDescriptor().getName(), + new SecurityInfo("hbase.master.kerberos.principal", Kind.HBASE_AUTH_TOKEN)); + // NOTE: IF ADDING A NEW SERVICE, BE SURE TO UPDATE HBasePolicyProvider ALSO ELSE + // new Service will not be found when all is Kerberized!!!! } /** diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java index 41abf97696f5..1253974e0c42 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/RequestConverter.java @@ -25,6 +25,7 @@ import java.util.Map; import java.util.Set; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.apache.hadoop.hbase.CellScannable; import org.apache.hadoop.hbase.ClusterMetrics.Option; @@ -1888,4 +1889,27 @@ private static List toProtoServerNames(List return TransitReplicationPeerSyncReplicationStateRequest.newBuilder().setPeerId(peerId) .setSyncReplicationState(ReplicationPeerConfigUtil.toSyncReplicationState(state)).build(); } + + // HBCK2 + public static MasterProtos.AssignsRequest toAssignRegionsRequest( + List encodedRegionNames, boolean override) { + MasterProtos.AssignsRequest.Builder b = MasterProtos.AssignsRequest.newBuilder(); + return b.addAllRegion(toEncodedRegionNameRegionSpecifiers(encodedRegionNames)). + setOverride(override).build(); + } + + public static MasterProtos.UnassignsRequest toUnassignRegionsRequest( + List encodedRegionNames, boolean override) { + MasterProtos.UnassignsRequest.Builder b = + MasterProtos.UnassignsRequest.newBuilder(); + return b.addAllRegion(toEncodedRegionNameRegionSpecifiers(encodedRegionNames)). + setOverride(override).build(); + } + + private static List toEncodedRegionNameRegionSpecifiers( + List encodedRegionNames) { + return encodedRegionNames.stream(). + map(r -> buildRegionSpecifier(RegionSpecifierType.ENCODED_REGION_NAME, Bytes.toBytes(r))). + collect(Collectors.toList()); + } } diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java index beb65faa7214..fbfab4b60bcf 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java @@ -1325,6 +1325,7 @@ public enum OperationStatusCode { "hbase.regionserver.region.split.threads.max"; /** Canary config keys */ + // TODO: Move these defines to Canary Class public static final String HBASE_CANARY_WRITE_DATA_TTL_KEY = "hbase.canary.write.data.ttl"; public static final String HBASE_CANARY_WRITE_PERSERVER_REGIONS_LOWERLIMIT_KEY = diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/ByteBufferUtils.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/ByteBufferUtils.java index 11745a4d96d3..deb667b6727d 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/ByteBufferUtils.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/ByteBufferUtils.java @@ -55,7 +55,267 @@ public final class ByteBufferUtils { private ByteBufferUtils() { } - /** + + static abstract class Comparer { + abstract int compareTo(byte [] buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2); + abstract int compareTo(ByteBuffer buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2); + } + + static abstract class Converter { + abstract short toShort(ByteBuffer buffer, int offset); + abstract int toInt(ByteBuffer buffer); + abstract int toInt(ByteBuffer buffer, int offset); + abstract long toLong(ByteBuffer buffer, int offset); + abstract void putInt(ByteBuffer buffer, int val); + abstract int putInt(ByteBuffer buffer, int index, int val); + abstract void putShort(ByteBuffer buffer, short val); + abstract int putShort(ByteBuffer buffer, int index, short val); + abstract void putLong(ByteBuffer buffer, long val); + abstract int putLong(ByteBuffer buffer, int index, long val); + } + + static class ComparerHolder { + static final String UNSAFE_COMPARER_NAME = ComparerHolder.class.getName() + "$UnsafeComparer"; + + static final Comparer BEST_COMPARER = getBestComparer(); + + static Comparer getBestComparer() { + try { + Class theClass = Class.forName(UNSAFE_COMPARER_NAME); + + @SuppressWarnings("unchecked") + Comparer comparer = (Comparer) theClass.getConstructor().newInstance(); + return comparer; + } catch (Throwable t) { // ensure we really catch *everything* + return PureJavaComparer.INSTANCE; + } + } + + static final class PureJavaComparer extends Comparer { + static final PureJavaComparer INSTANCE = new PureJavaComparer(); + + private PureJavaComparer() {} + + @Override + public int compareTo(byte [] buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2) { + int end1 = o1 + l1; + int end2 = o2 + l2; + for (int i = o1, j = o2; i < end1 && j < end2; i++, j++) { + int a = buf1[i] & 0xFF; + int b = buf2.get(j) & 0xFF; + if (a != b) { + return a - b; + } + } + return l1 - l2; + } + + @Override + public int compareTo(ByteBuffer buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2) { + int end1 = o1 + l1; + int end2 = o2 + l2; + for (int i = o1, j = o2; i < end1 && j < end2; i++, j++) { + int a = buf1.get(i) & 0xFF; + int b = buf2.get(j) & 0xFF; + if (a != b) { + return a - b; + } + } + return l1 - l2; + } + } + + static final class UnsafeComparer extends Comparer { + + public UnsafeComparer() {} + + static { + if(!UNSAFE_UNALIGNED) { + throw new Error(); + } + } + + @Override + public int compareTo(byte[] buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2) { + long offset2Adj; + Object refObj2 = null; + if (buf2.isDirect()) { + offset2Adj = o2 + ((DirectBuffer)buf2).address(); + } else { + offset2Adj = o2 + buf2.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; + refObj2 = buf2.array(); + } + return compareToUnsafe(buf1, o1 + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET, l1, + refObj2, offset2Adj, l2); + } + + @Override + public int compareTo(ByteBuffer buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2) { + long offset1Adj, offset2Adj; + Object refObj1 = null, refObj2 = null; + if (buf1.isDirect()) { + offset1Adj = o1 + ((DirectBuffer) buf1).address(); + } else { + offset1Adj = o1 + buf1.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; + refObj1 = buf1.array(); + } + if (buf2.isDirect()) { + offset2Adj = o2 + ((DirectBuffer) buf2).address(); + } else { + offset2Adj = o2 + buf2.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; + refObj2 = buf2.array(); + } + return compareToUnsafe(refObj1, offset1Adj, l1, refObj2, offset2Adj, l2); + } + } + } + + + static class ConverterHolder { + static final String UNSAFE_CONVERTER_NAME = + ConverterHolder.class.getName() + "$UnsafeConverter"; + static final Converter BEST_CONVERTER = getBestConverter(); + + static Converter getBestConverter() { + try { + Class theClass = Class.forName(UNSAFE_CONVERTER_NAME); + + // yes, UnsafeComparer does implement Comparer + @SuppressWarnings("unchecked") + Converter converter = (Converter) theClass.getConstructor().newInstance(); + return converter; + } catch (Throwable t) { // ensure we really catch *everything* + return PureJavaConverter.INSTANCE; + } + } + + static final class PureJavaConverter extends Converter { + static final PureJavaConverter INSTANCE = new PureJavaConverter(); + + private PureJavaConverter() {} + + @Override + short toShort(ByteBuffer buffer, int offset) { + return buffer.getShort(offset); + } + + @Override + int toInt(ByteBuffer buffer) { + return buffer.getInt(); + } + + @Override + int toInt(ByteBuffer buffer, int offset) { + return buffer.getInt(offset); + } + + @Override + long toLong(ByteBuffer buffer, int offset) { + return buffer.getLong(offset); + } + + @Override + void putInt(ByteBuffer buffer, int val) { + buffer.putInt(val); + } + + @Override + int putInt(ByteBuffer buffer, int index, int val) { + buffer.putInt(index, val); + return index + Bytes.SIZEOF_INT; + } + + @Override + void putShort(ByteBuffer buffer, short val) { + buffer.putShort(val); + } + + @Override + int putShort(ByteBuffer buffer, int index, short val) { + buffer.putShort(index, val); + return index + Bytes.SIZEOF_SHORT; + } + + @Override + void putLong(ByteBuffer buffer, long val) { + buffer.putLong(val); + } + + @Override + int putLong(ByteBuffer buffer, int index, long val) { + buffer.putLong(index, val); + return index + Bytes.SIZEOF_LONG; + } + } + + static final class UnsafeConverter extends Converter { + + public UnsafeConverter() {} + + static { + if(!UNSAFE_UNALIGNED) { + throw new Error(); + } + } + + @Override + short toShort(ByteBuffer buffer, int offset) { + return UnsafeAccess.toShort(buffer, offset); + } + + @Override + int toInt(ByteBuffer buffer) { + int i = UnsafeAccess.toInt(buffer, buffer.position()); + buffer.position(buffer.position() + Bytes.SIZEOF_INT); + return i; + } + + @Override + int toInt(ByteBuffer buffer, int offset) { + return UnsafeAccess.toInt(buffer, offset); + } + + @Override + long toLong(ByteBuffer buffer, int offset) { + return UnsafeAccess.toLong(buffer, offset); + } + + @Override + void putInt(ByteBuffer buffer, int val) { + int newPos = UnsafeAccess.putInt(buffer, buffer.position(), val); + buffer.position(newPos); + } + + @Override + int putInt(ByteBuffer buffer, int index, int val) { + return UnsafeAccess.putInt(buffer, index, val); + } + + @Override + void putShort(ByteBuffer buffer, short val) { + int newPos = UnsafeAccess.putShort(buffer, buffer.position(), val); + buffer.position(newPos); + } + + @Override + int putShort(ByteBuffer buffer, int index, short val) { + return UnsafeAccess.putShort(buffer, index, val); + } + + @Override + void putLong(ByteBuffer buffer, long val) { + int newPos = UnsafeAccess.putLong(buffer, buffer.position(), val); + buffer.position(newPos); + } + + @Override + int putLong(ByteBuffer buffer, int index, long val) { + return UnsafeAccess.putLong(buffer, index, val); + } + } + } + + /** * Similar to {@link WritableUtils#writeVLong(java.io.DataOutput, long)}, * but writes to a {@link ByteBuffer}. */ @@ -629,35 +889,7 @@ public static int hashCode(ByteBuffer buf, int offset, int length) { } public static int compareTo(ByteBuffer buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2) { - // NOTE: This method is copied over in BBKVComparator!!!!! For perf reasons. If you make - // changes here, make them there too!!!! - if (UNSAFE_UNALIGNED) { - long offset1Adj, offset2Adj; - Object refObj1 = null, refObj2 = null; - if (buf1.isDirect()) { - offset1Adj = o1 + ((DirectBuffer) buf1).address(); - } else { - offset1Adj = o1 + buf1.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; - refObj1 = buf1.array(); - } - if (buf2.isDirect()) { - offset2Adj = o2 + ((DirectBuffer) buf2).address(); - } else { - offset2Adj = o2 + buf2.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; - refObj2 = buf2.array(); - } - return compareToUnsafe(refObj1, offset1Adj, l1, refObj2, offset2Adj, l2); - } - int end1 = o1 + l1; - int end2 = o2 + l2; - for (int i = o1, j = o2; i < end1 && j < end2; i++, j++) { - int a = buf1.get(i) & 0xFF; - int b = buf2.get(j) & 0xFF; - if (a != b) { - return a - b; - } - } - return l1 - l2; + return ComparerHolder.BEST_COMPARER.compareTo(buf1, o1, l1, buf2, o2, l2); } public static boolean equals(ByteBuffer buf1, int o1, int l1, byte[] buf2, int o2, int l2) { @@ -678,53 +910,11 @@ public static boolean equals(ByteBuffer buf1, int o1, int l1, byte[] buf2, int o // of compiled code via jitwatch). public static int compareTo(byte [] buf1, int o1, int l1, ByteBuffer buf2, int o2, int l2) { - if (UNSAFE_UNALIGNED) { - long offset2Adj; - Object refObj2 = null; - if (buf2.isDirect()) { - offset2Adj = o2 + ((DirectBuffer)buf2).address(); - } else { - offset2Adj = o2 + buf2.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; - refObj2 = buf2.array(); - } - return compareToUnsafe(buf1, o1 + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET, l1, - refObj2, offset2Adj, l2); - } - int end1 = o1 + l1; - int end2 = o2 + l2; - for (int i = o1, j = o2; i < end1 && j < end2; i++, j++) { - int a = buf1[i] & 0xFF; - int b = buf2.get(j) & 0xFF; - if (a != b) { - return a - b; - } - } - return l1 - l2; + return ComparerHolder.BEST_COMPARER.compareTo(buf1, o1, l1, buf2, o2, l2); } public static int compareTo(ByteBuffer buf1, int o1, int l1, byte[] buf2, int o2, int l2) { - if (UNSAFE_UNALIGNED) { - long offset1Adj; - Object refObj1 = null; - if (buf1.isDirect()) { - offset1Adj = o1 + ((DirectBuffer) buf1).address(); - } else { - offset1Adj = o1 + buf1.arrayOffset() + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET; - refObj1 = buf1.array(); - } - return compareToUnsafe(refObj1, offset1Adj, l1, - buf2, o2 + UnsafeAccess.BYTE_ARRAY_BASE_OFFSET, l2); - } - int end1 = o1 + l1; - int end2 = o2 + l2; - for (int i = o1, j = o2; i < end1 && j < end2; i++, j++) { - int a = buf1.get(i) & 0xFF; - int b = buf2[j] & 0xFF; - if (a != b) { - return a - b; - } - } - return l1 - l2; + return compareTo(buf2, o2, l2, buf1, o1, l1)*-1; } static int compareToUnsafe(Object obj1, long o1, int l1, Object obj2, long o2, int l2) { @@ -777,24 +967,14 @@ static int compareToUnsafe(Object obj1, long o1, int l1, Object obj2, long o2, i * @return short value at offset */ public static short toShort(ByteBuffer buffer, int offset) { - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.toShort(buffer, offset); - } else { - return buffer.getShort(offset); - } + return ConverterHolder.BEST_CONVERTER.toShort(buffer, offset); } /** * Reads an int value at the given buffer's current position. Also advances the buffer's position */ public static int toInt(ByteBuffer buffer) { - if (UNSAFE_UNALIGNED) { - int i = UnsafeAccess.toInt(buffer, buffer.position()); - buffer.position(buffer.position() + Bytes.SIZEOF_INT); - return i; - } else { - return buffer.getInt(); - } + return ConverterHolder.BEST_CONVERTER.toInt(buffer); } /** @@ -804,11 +984,7 @@ public static int toInt(ByteBuffer buffer) { * @return int value at offset */ public static int toInt(ByteBuffer buffer, int offset) { - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.toInt(buffer, offset); - } else { - return buffer.getInt(offset); - } + return ConverterHolder.BEST_CONVERTER.toInt(buffer, offset); } /** @@ -841,11 +1017,7 @@ public static int readAsInt(ByteBuffer buf, int offset, final int length) { * @return long value at offset */ public static long toLong(ByteBuffer buffer, int offset) { - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.toLong(buffer, offset); - } else { - return buffer.getLong(offset); - } + return ConverterHolder.BEST_CONVERTER.toLong(buffer, offset); } /** @@ -855,20 +1027,11 @@ public static long toLong(ByteBuffer buffer, int offset) { * @param val int to write out */ public static void putInt(ByteBuffer buffer, int val) { - if (UNSAFE_UNALIGNED) { - int newPos = UnsafeAccess.putInt(buffer, buffer.position(), val); - buffer.position(newPos); - } else { - buffer.putInt(val); - } + ConverterHolder.BEST_CONVERTER.putInt(buffer, val); } public static int putInt(ByteBuffer buffer, int index, int val) { - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.putInt(buffer, index, val); - } - buffer.putInt(index, val); - return index + Bytes.SIZEOF_INT; + return ConverterHolder.BEST_CONVERTER.putInt(buffer, index, val); } /** @@ -906,20 +1069,11 @@ public static BigDecimal toBigDecimal(ByteBuffer buffer, int offset, int length) * @param val short to write out */ public static void putShort(ByteBuffer buffer, short val) { - if (UNSAFE_UNALIGNED) { - int newPos = UnsafeAccess.putShort(buffer, buffer.position(), val); - buffer.position(newPos); - } else { - buffer.putShort(val); - } + ConverterHolder.BEST_CONVERTER.putShort(buffer, val); } public static int putShort(ByteBuffer buffer, int index, short val) { - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.putShort(buffer, index, val); - } - buffer.putShort(index, val); - return index + Bytes.SIZEOF_SHORT; + return ConverterHolder.BEST_CONVERTER.putShort(buffer, index, val); } public static int putAsShort(ByteBuffer buf, int index, int val) { @@ -936,20 +1090,11 @@ public static int putAsShort(ByteBuffer buf, int index, int val) { * @param val long to write out */ public static void putLong(ByteBuffer buffer, long val) { - if (UNSAFE_UNALIGNED) { - int newPos = UnsafeAccess.putLong(buffer, buffer.position(), val); - buffer.position(newPos); - } else { - buffer.putLong(val); - } + ConverterHolder.BEST_CONVERTER.putLong(buffer, val); } public static int putLong(ByteBuffer buffer, int index, long val) { - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.putLong(buffer, index, val); - } - buffer.putLong(index, val); - return index + Bytes.SIZEOF_LONG; + return ConverterHolder.BEST_CONVERTER.putLong(buffer, index, val); } /** diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java index e63c0db5b2d6..dcc1266df92c 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Bytes.java @@ -130,7 +130,8 @@ public class Bytes implements Comparable { // SizeOf which uses java.lang.instrument says 24 bytes. (3 longs?) public static final int ESTIMATED_HEAP_TAX = 16; - private static final boolean UNSAFE_UNALIGNED = UnsafeAvailChecker.unaligned(); + @VisibleForTesting + static final boolean UNSAFE_UNALIGNED = UnsafeAvailChecker.unaligned(); /** * Returns length of the byte array, returning 0 if the array is null. @@ -811,16 +812,7 @@ public static long toLong(byte[] bytes, int offset, final int length) { if (length != SIZEOF_LONG || offset + length > bytes.length) { throw explainWrongLengthOrOffset(bytes, offset, length, SIZEOF_LONG); } - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.toLong(bytes, offset); - } else { - long l = 0; - for(int i = offset; i < offset + length; i++) { - l <<= 8; - l ^= bytes[i] & 0xFF; - } - return l; - } + return ConverterHolder.BEST_CONVERTER.toLong(bytes, offset, length); } private static IllegalArgumentException @@ -852,16 +844,7 @@ public static int putLong(byte[] bytes, int offset, long val) { throw new IllegalArgumentException("Not enough room to put a long at" + " offset " + offset + " in a " + bytes.length + " byte array"); } - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.putLong(bytes, offset, val); - } else { - for(int i = offset + 7; i > offset; i--) { - bytes[i] = (byte) val; - val >>>= 8; - } - bytes[offset] = (byte) val; - return offset + SIZEOF_LONG; - } + return ConverterHolder.BEST_CONVERTER.putLong(bytes, offset, val); } /** @@ -1003,16 +986,7 @@ public static int toInt(byte[] bytes, int offset, final int length) { if (length != SIZEOF_INT || offset + length > bytes.length) { throw explainWrongLengthOrOffset(bytes, offset, length, SIZEOF_INT); } - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.toInt(bytes, offset); - } else { - int n = 0; - for(int i = offset; i < (offset + length); i++) { - n <<= 8; - n ^= bytes[i] & 0xFF; - } - return n; - } + return ConverterHolder.BEST_CONVERTER.toInt(bytes, offset, length); } /** @@ -1087,16 +1061,7 @@ public static int putInt(byte[] bytes, int offset, int val) { throw new IllegalArgumentException("Not enough room to put an int at" + " offset " + offset + " in a " + bytes.length + " byte array"); } - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.putInt(bytes, offset, val); - } else { - for(int i= offset + 3; i > offset; i--) { - bytes[i] = (byte) val; - val >>>= 8; - } - bytes[offset] = (byte) val; - return offset + SIZEOF_INT; - } + return ConverterHolder.BEST_CONVERTER.putInt(bytes, offset, val); } /** @@ -1157,15 +1122,7 @@ public static short toShort(byte[] bytes, int offset, final int length) { if (length != SIZEOF_SHORT || offset + length > bytes.length) { throw explainWrongLengthOrOffset(bytes, offset, length, SIZEOF_SHORT); } - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.toShort(bytes, offset); - } else { - short n = 0; - n = (short) ((n ^ bytes[offset]) & 0xFF); - n = (short) (n << 8); - n = (short) ((n ^ bytes[offset+1]) & 0xFF); - return n; - } + return ConverterHolder.BEST_CONVERTER.toShort(bytes, offset, length); } /** @@ -1195,14 +1152,7 @@ public static int putShort(byte[] bytes, int offset, short val) { throw new IllegalArgumentException("Not enough room to put a short at" + " offset " + offset + " in a " + bytes.length + " byte array"); } - if (UNSAFE_UNALIGNED) { - return UnsafeAccess.putShort(bytes, offset, val); - } else { - bytes[offset+1] = (byte) val; - val >>= 8; - bytes[offset] = (byte) val; - return offset + SIZEOF_SHORT; - } + return ConverterHolder.BEST_CONVERTER.putShort(bytes, offset, val); } /** @@ -1431,11 +1381,161 @@ int compareTo( ); } + static abstract class Converter { + abstract long toLong(byte[] bytes, int offset, int length); + abstract int putLong(byte[] bytes, int offset, long val); + + abstract int toInt(byte[] bytes, int offset, final int length); + abstract int putInt(byte[] bytes, int offset, int val); + + abstract short toShort(byte[] bytes, int offset, final int length); + abstract int putShort(byte[] bytes, int offset, short val); + + } + @VisibleForTesting static Comparer lexicographicalComparerJavaImpl() { return LexicographicalComparerHolder.PureJavaComparer.INSTANCE; } + static class ConverterHolder { + static final String UNSAFE_CONVERTER_NAME = + ConverterHolder.class.getName() + "$UnsafeConverter"; + + static final Converter BEST_CONVERTER = getBestConverter(); + /** + * Returns the Unsafe-using Converter, or falls back to the pure-Java + * implementation if unable to do so. + */ + static Converter getBestConverter() { + try { + Class theClass = Class.forName(UNSAFE_CONVERTER_NAME); + + // yes, UnsafeComparer does implement Comparer + @SuppressWarnings("unchecked") + Converter converter = (Converter) theClass.getConstructor().newInstance(); + return converter; + } catch (Throwable t) { // ensure we really catch *everything* + return PureJavaConverter.INSTANCE; + } + } + + protected static final class PureJavaConverter extends Converter { + static final PureJavaConverter INSTANCE = new PureJavaConverter(); + + private PureJavaConverter() {} + + @Override + long toLong(byte[] bytes, int offset, int length) { + long l = 0; + for(int i = offset; i < offset + length; i++) { + l <<= 8; + l ^= bytes[i] & 0xFF; + } + return l; + } + + @Override + int putLong(byte[] bytes, int offset, long val) { + for(int i = offset + 7; i > offset; i--) { + bytes[i] = (byte) val; + val >>>= 8; + } + bytes[offset] = (byte) val; + return offset + SIZEOF_LONG; + } + + @Override + int toInt(byte[] bytes, int offset, int length) { + int n = 0; + for(int i = offset; i < (offset + length); i++) { + n <<= 8; + n ^= bytes[i] & 0xFF; + } + return n; + } + + @Override + int putInt(byte[] bytes, int offset, int val) { + for(int i= offset + 3; i > offset; i--) { + bytes[i] = (byte) val; + val >>>= 8; + } + bytes[offset] = (byte) val; + return offset + SIZEOF_INT; + } + + @Override + short toShort(byte[] bytes, int offset, int length) { + short n = 0; + n = (short) ((n ^ bytes[offset]) & 0xFF); + n = (short) (n << 8); + n ^= (short) (bytes[offset+1] & 0xFF); + return n; + } + + @Override + int putShort(byte[] bytes, int offset, short val) { + bytes[offset+1] = (byte) val; + val >>= 8; + bytes[offset] = (byte) val; + return offset + SIZEOF_SHORT; + } + } + + protected static final class UnsafeConverter extends Converter { + + static final Unsafe theUnsafe; + + public UnsafeConverter() {} + + static { + if (UNSAFE_UNALIGNED) { + theUnsafe = UnsafeAccess.theUnsafe; + } else { + // It doesn't matter what we throw; + // it's swallowed in getBestComparer(). + throw new Error(); + } + + // sanity check - this should never fail + if (theUnsafe.arrayIndexScale(byte[].class) != 1) { + throw new AssertionError(); + } + } + + @Override + long toLong(byte[] bytes, int offset, int length) { + return UnsafeAccess.toLong(bytes, offset); + } + + @Override + int putLong(byte[] bytes, int offset, long val) { + return UnsafeAccess.putLong(bytes, offset, val); + } + + @Override + int toInt(byte[] bytes, int offset, int length) { + return UnsafeAccess.toInt(bytes, offset); + } + + @Override + int putInt(byte[] bytes, int offset, int val) { + return UnsafeAccess.putInt(bytes, offset, val); + } + + @Override + short toShort(byte[] bytes, int offset, int length) { + return UnsafeAccess.toShort(bytes, offset); + } + + @Override + int putShort(byte[] bytes, int offset, short val) { + return UnsafeAccess.putShort(bytes, offset, val); + } + } + } + /** * Provides a lexicographical comparer implementation; either a Java * implementation or a faster implementation based on {@link Unsafe}. diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/CommonFSUtils.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/CommonFSUtils.java index 8924098bec24..899c63328381 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/CommonFSUtils.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/CommonFSUtils.java @@ -420,6 +420,34 @@ private static boolean isValidWALRootDir(Path walDir, final Configuration c) thr return true; } + /** + * Returns the WAL region directory based on the given table name and region name + * @param conf configuration to determine WALRootDir + * @param tableName Table that the region is under + * @param encodedRegionName Region name used for creating the final region directory + * @return the region directory used to store WALs under the WALRootDir + * @throws IOException if there is an exception determining the WALRootDir + */ + public static Path getWALRegionDir(final Configuration conf, + final TableName tableName, final String encodedRegionName) + throws IOException { + return new Path(getWALTableDir(conf, tableName), + encodedRegionName); + } + + /** + * Returns the Table directory under the WALRootDir for the specified table name + * @param conf configuration used to get the WALRootDir + * @param tableName Table to get the directory for + * @return a path to the WAL table directory for the specified table + * @throws IOException if there is an exception determining the WALRootDir + */ + public static Path getWALTableDir(final Configuration conf, final TableName tableName) + throws IOException { + return new Path(new Path(getWALRootDir(conf), tableName.getNamespaceAsString()), + tableName.getQualifierAsString()); + } + /** * Returns the {@link org.apache.hadoop.fs.Path} object representing the table directory under * path rootdir diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/IdLock.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/IdLock.java index 414cc66fd8fc..c4adfbff154c 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/IdLock.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/IdLock.java @@ -81,6 +81,17 @@ public Entry getLockEntry(long id) throws IOException { existing.wait(); } catch (InterruptedException e) { --existing.numWaiters; // Remove ourselves from waiters. + // HBASE-21292 + // There is a rare case that interrupting and the lock owner thread call + // releaseLockEntry at the same time. Since the owner thread found there + // still one waiting, it won't remove the entry from the map. If the interrupted + // thread is the last one waiting on the lock, and since an exception is thrown, + // the 'existing' entry will stay in the map forever. Later threads which try to + // get this lock will stuck in a infinite loop because + // existing = map.putIfAbsent(entry.id, entry)) != null and existing.locked=false. + if (!existing.locked && existing.numWaiters == 0) { + map.remove(existing.id); + } throw new InterruptedIOException( "Interrupted waiting to acquire sparse lock"); } @@ -135,6 +146,12 @@ public Entry tryLockEntry(long id, long time) throws IOException { } } catch (InterruptedException e) { + // HBASE-21292 + // Please refer to the comments in getLockEntry() + // the difference here is that we decrease numWaiters in finally block + if (!existing.locked && existing.numWaiters == 1) { + map.remove(existing.id); + } throw new InterruptedIOException( "Interrupted waiting to acquire sparse lock"); } finally { diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Random64.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Random64.java new file mode 100644 index 000000000000..f337b5f745dc --- /dev/null +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Random64.java @@ -0,0 +1,149 @@ +/** + * + * 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.util; + +import java.util.HashSet; +import java.util.Random; +import java.util.Set; +import java.util.concurrent.atomic.AtomicLong; +import org.apache.yetus.audience.InterfaceAudience; +import org.apache.hbase.thirdparty.com.google.common.base.Preconditions; + +/** + * + * An instance of this class is used to generate a stream of + * pseudorandom numbers. The class uses a 64-bit seed, which is + * modified using a linear congruential formula. + * + * see https://en.wikipedia.org/wiki/Linear_congruential_generator + */ +@InterfaceAudience.Private +public class Random64 { + + private static final long multiplier = 6364136223846793005L; + private static final long addend = 1442695040888963407L; + + private static final AtomicLong seedUniquifier + = new AtomicLong(8682522807148012L); + + private long seed; + + /** + * Copy from {@link Random#seedUniquifier()} + */ + private static long seedUniquifier() { + for (; ; ) { + long current = seedUniquifier.get(); + long next = current * 181783497276652981L; + if (seedUniquifier.compareAndSet(current, next)) { + return next; + } + } + } + + public Random64() { + this(seedUniquifier() ^ System.nanoTime()); + } + + public Random64(long seed) { + this.seed = seed; + } + + public long nextLong() { + return next64(64); + } + + public void nextBytes(byte[] bytes) { + for (int i = 0, len = bytes.length; i < len;) { + // We regard seed as unsigned long, therefore used '>>>' instead of '>>'. + for (long rnd = nextLong(), n = Math.min(len - i, Long.SIZE / Byte.SIZE); + n-- > 0; rnd >>>= Byte.SIZE) { + bytes[i++] = (byte) rnd; + } + } + } + + private long next64(int bits) { + seed = seed * multiplier + addend; + return seed >>> (64 - bits); + } + + + /** + * Random64 is a pseudorandom algorithm(LCG). Therefore, we will get same sequence + * if seeds are the same. This main will test how many calls nextLong() it will + * get the same seed. + * + * We do not need to save all numbers (that is too large). We could save + * once every 100000 calls nextLong(). If it get a same seed, we can + * detect this by calling nextLong() 100000 times continuously. + * + */ + public static void main(String[] args) { + long defaultTotalTestCnt = 1000000000000L; // 1 trillion + + if (args.length == 1) { + defaultTotalTestCnt = Long.parseLong(args[0]); + } + + Preconditions.checkArgument(defaultTotalTestCnt > 0, "totalTestCnt <= 0"); + + final int precision = 100000; + final long totalTestCnt = defaultTotalTestCnt + precision; + final int reportPeriod = 100 * precision; + final long startTime = System.currentTimeMillis(); + + System.out.println("Do collision test, totalTestCnt=" + totalTestCnt); + + Random64 rand = new Random64(); + Set longSet = new HashSet<>(); + + for (long cnt = 1; cnt <= totalTestCnt; cnt++) { + final long randLong = rand.nextLong(); + + if (longSet.contains(randLong)) { + System.err.println("Conflict! count=" + cnt); + System.exit(1); + } + + if (cnt % precision == 0) { + if (!longSet.add(randLong)) { + System.err.println("Conflict! count=" + cnt); + System.exit(1); + } + + if (cnt % reportPeriod == 0) { + long cost = System.currentTimeMillis() - startTime; + long remainingMs = (long) (1.0 * (totalTestCnt - cnt) * cost / cnt); + System.out.println( + String.format( + "Progress: %.3f%%, remaining %d minutes", + 100.0 * cnt / totalTestCnt, remainingMs / 60000 + ) + ); + } + } + + } + + System.out.println("No collision!"); + } + +} diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/RetryCounter.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/RetryCounter.java index 4c163fd1c308..a2f09d08170d 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/RetryCounter.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/RetryCounter.java @@ -18,12 +18,15 @@ */ package org.apache.hadoop.hbase.util; +import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeUnit; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.hbase.thirdparty.com.google.common.base.Preconditions; + /** * Operation retry accounting. * Use to calculate wait period, {@link #getBackoffTimeAndIncrementAttempts()}}, or for performing @@ -44,6 +47,7 @@ public static class RetryConfig { private long maxSleepTime; private TimeUnit timeUnit; private BackoffPolicy backoffPolicy; + private float jitter; private static final BackoffPolicy DEFAULT_BACKOFF_POLICY = new ExponentialBackoffPolicy(); @@ -53,6 +57,7 @@ public RetryConfig() { maxSleepTime = -1; timeUnit = TimeUnit.MILLISECONDS; backoffPolicy = DEFAULT_BACKOFF_POLICY; + jitter = 0.0f; } public RetryConfig(int maxAttempts, long sleepInterval, long maxSleepTime, @@ -89,6 +94,13 @@ public RetryConfig setTimeUnit(TimeUnit timeUnit) { return this; } + public RetryConfig setJitter(float jitter) { + Preconditions.checkArgument(jitter >= 0.0f && jitter < 1.0f, + "Invalid jitter: %s, should be in range [0.0, 1.0)", jitter); + this.jitter = jitter; + return this; + } + public int getMaxAttempts() { return maxAttempts; } @@ -105,17 +117,26 @@ public TimeUnit getTimeUnit() { return timeUnit; } + public float getJitter() { + return jitter; + } + public BackoffPolicy getBackoffPolicy() { return backoffPolicy; } } + private static long addJitter(long interval, float jitter) { + long jitterInterval = (long) (interval * ThreadLocalRandom.current().nextFloat() * jitter); + return interval + jitterInterval; + } + /** * Policy for calculating sleeping intervals between retry attempts */ public static class BackoffPolicy { public long getBackoffTime(RetryConfig config, int attempts) { - return config.getSleepInterval(); + return addJitter(config.getSleepInterval(), config.getJitter()); } } @@ -123,7 +144,7 @@ public static class ExponentialBackoffPolicy extends BackoffPolicy { @Override public long getBackoffTime(RetryConfig config, int attempts) { long backoffTime = (long) (config.getSleepInterval() * Math.pow(2, attempts)); - return backoffTime; + return addJitter(backoffTime, config.getJitter()); } } @@ -155,7 +176,6 @@ public int getMaxAttempts() { /** * Sleep for a back off time as supplied by the backoff policy, and increases the attempts - * @throws InterruptedException */ public void sleepUntilNextRetry() throws InterruptedException { int attempts = getAttemptTimes(); diff --git a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Sleeper.java b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Sleeper.java index 7d4d692e1a11..93ef08cc605e 100644 --- a/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Sleeper.java +++ b/hbase-common/src/main/java/org/apache/hadoop/hbase/util/Sleeper.java @@ -49,13 +49,6 @@ public Sleeper(final int sleep, final Stoppable stopper) { this.stopper = stopper; } - /** - * Sleep for period. - */ - public void sleep() { - sleep(System.currentTimeMillis()); - } - /** * If currently asleep, stops sleeping; if not asleep, will skip the next * sleep cycle. @@ -68,28 +61,24 @@ public void skipSleepCycle() { } /** - * Sleep for period adjusted by passed startTime - * @param startTime Time some task started previous to now. Time to sleep - * will be docked current time minus passed startTime. + * Sleep for period. */ - public void sleep(final long startTime) { + public void sleep() { + sleep(this.period); + } + + public void sleep(long sleepTime) { if (this.stopper.isStopped()) { return; } long now = System.currentTimeMillis(); - long waitTime = this.period - (now - startTime); - if (waitTime > this.period) { - LOG.warn("Calculated wait time > " + this.period + - "; setting to this.period: " + System.currentTimeMillis() + ", " + - startTime); - waitTime = this.period; - } - while (waitTime > 0) { + long currentSleepTime = sleepTime; + while (currentSleepTime > 0) { long woke = -1; try { synchronized (sleepLock) { if (triggerWake) break; - sleepLock.wait(waitTime); + sleepLock.wait(currentSleepTime); } woke = System.currentTimeMillis(); long slept = woke - now; @@ -108,7 +97,7 @@ public void sleep(final long startTime) { } // Recalculate waitTime. woke = (woke == -1)? System.currentTimeMillis(): woke; - waitTime = this.period - (woke - startTime); + currentSleepTime = this.period - (woke - now); } synchronized(sleepLock) { triggerWake = false; diff --git a/hbase-common/src/saveVersion.sh b/hbase-common/src/saveVersion.sh index abb8c5bcff8b..730224f0d653 100644 --- a/hbase-common/src/saveVersion.sh +++ b/hbase-common/src/saveVersion.sh @@ -38,7 +38,7 @@ if [ -d .svn ]; then revision=`svn info | sed -n -e 's/Last Changed Rev: \(.*\)/\1/p'` url=`svn info | sed -n -e 's/^URL: \(.*\)/\1/p'` elif [ -d .git ]; then - revision=`git log -1 --pretty=format:"%H"` + revision=`git log -1 --no-show-signature --pretty=format:"%H"` hostname=`hostname` url="git://${hostname}${cwd}" else diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/ResourceCheckerJUnitListener.java b/hbase-common/src/test/java/org/apache/hadoop/hbase/ResourceCheckerJUnitListener.java index d8df1379252e..225d94f42b45 100644 --- a/hbase-common/src/test/java/org/apache/hadoop/hbase/ResourceCheckerJUnitListener.java +++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/ResourceCheckerJUnitListener.java @@ -18,15 +18,12 @@ package org.apache.hadoop.hbase; -import java.lang.management.ManagementFactory; -import java.lang.management.MemoryUsage; import java.util.ArrayList; import java.util.HashSet; import java.util.List; import java.util.Map; import java.util.Set; import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.TimeUnit; import org.apache.hadoop.hbase.ResourceChecker.Phase; import org.apache.hadoop.hbase.util.JVM; import org.junit.runner.notification.RunListener; @@ -142,41 +139,6 @@ public int getVal(Phase phase) { } } - static class MaxHeapMemoryMBResourceAnalyzer extends ResourceChecker.ResourceAnalyzer { - - @Override - public int getVal(Phase phase) { - MemoryUsage usage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage(); - return (int) (usage.getMax() / (1024 * 1024)); - } - } - - static class UsedHeapMemoryMBResourceAnalyzer extends ResourceChecker.ResourceAnalyzer { - - @Override - public int getVal(Phase phase) { - MemoryUsage usage = ManagementFactory.getMemoryMXBean().getHeapMemoryUsage(); - return (int) (usage.getUsed() / (1024 * 1024)); - } - } - - static class GCCountResourceAnalyzer extends ResourceChecker.ResourceAnalyzer { - - @Override - public int getVal(Phase phase) { - return Math.toIntExact(ManagementFactory.getGarbageCollectorMXBeans().stream() - .mapToLong(b -> b.getCollectionCount()).sum()); - } - } - - static class GCTimeSecondResourceAnalyzer extends ResourceChecker.ResourceAnalyzer { - - @Override - public int getVal(Phase phase) { - return Math.toIntExact(TimeUnit.MILLISECONDS.toSeconds(ManagementFactory - .getGarbageCollectorMXBeans().stream().mapToLong(b -> b.getCollectionTime()).sum())); - } - } /** * To be implemented by sub classes if they want to add specific ResourceAnalyzer. @@ -193,10 +155,6 @@ private void start(String testName) { rc.addResourceAnalyzer(new SystemLoadAverageResourceAnalyzer()); rc.addResourceAnalyzer(new ProcessCountResourceAnalyzer()); rc.addResourceAnalyzer(new AvailableMemoryMBResourceAnalyzer()); - rc.addResourceAnalyzer(new MaxHeapMemoryMBResourceAnalyzer()); - rc.addResourceAnalyzer(new UsedHeapMemoryMBResourceAnalyzer()); - rc.addResourceAnalyzer(new GCCountResourceAnalyzer()); - rc.addResourceAnalyzer(new GCTimeSecondResourceAnalyzer()); addResourceAnalyzer(rc); diff --git a/hbase-common/src/test/java/org/apache/hadoop/hbase/util/TestBytes.java b/hbase-common/src/test/java/org/apache/hadoop/hbase/util/TestBytes.java index cea615e081a8..8b206e2b7418 100644 --- a/hbase-common/src/test/java/org/apache/hadoop/hbase/util/TestBytes.java +++ b/hbase-common/src/test/java/org/apache/hadoop/hbase/util/TestBytes.java @@ -22,6 +22,8 @@ import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.IOException; +import java.lang.reflect.Field; +import java.lang.reflect.Modifier; import java.math.BigDecimal; import java.nio.ByteBuffer; import java.util.ArrayList; @@ -44,6 +46,48 @@ public class TestBytes extends TestCase { public static final HBaseClassTestRule CLASS_RULE = HBaseClassTestRule.forClass(TestBytes.class); + private static void setUnsafe(boolean value) throws Exception { + Field field = Bytes.class.getDeclaredField("UNSAFE_UNALIGNED"); + field.setAccessible(true); + Field modifiersField = Field.class.getDeclaredField("modifiers"); + modifiersField.setAccessible(true); + int oldModifiers = field.getModifiers(); + modifiersField.setInt(field, oldModifiers & ~Modifier.FINAL); + try { + field.set(null, value); + } finally { + modifiersField.setInt(field, oldModifiers); + } + assertEquals(Bytes.UNSAFE_UNALIGNED, value); + } + + public void testShort() throws Exception { + testShort(false); + } + + public void testShortUnsafe() throws Exception { + testShort(true); + } + + private static void testShort(boolean unsafe) throws Exception { + setUnsafe(unsafe); + try { + for (short n : Arrays.asList( + Short.MIN_VALUE, + (short) -100, + (short) -1, + (short) 0, + (short) 1, + (short) 300, + Short.MAX_VALUE)) { + byte[] bytes = Bytes.toBytes(n); + assertEquals(Bytes.toShort(bytes, 0, bytes.length), n); + } + } finally { + setUnsafe(UnsafeAvailChecker.unaligned()); + } + } + public void testNullHashCode() { byte [] b = null; Exception ee = null; diff --git a/hbase-endpoint/pom.xml b/hbase-endpoint/pom.xml index 8950de17980e..d0b542554e04 100644 --- a/hbase-endpoint/pom.xml +++ b/hbase-endpoint/pom.xml @@ -177,6 +177,11 @@ test-jar test + + org.bouncycastle + bcprov-jdk15on + test + org.apache.hbase hbase-server @@ -229,12 +234,6 @@ mockito-core test - - - org.bouncycastle - bcprov-jdk16 - test - diff --git a/hbase-examples/src/main/java/org/apache/hadoop/hbase/client/example/RefreshHFilesClient.java b/hbase-examples/src/main/java/org/apache/hadoop/hbase/client/example/RefreshHFilesClient.java index ead0af0e74f0..06ad195c62ea 100644 --- a/hbase-examples/src/main/java/org/apache/hadoop/hbase/client/example/RefreshHFilesClient.java +++ b/hbase-examples/src/main/java/org/apache/hadoop/hbase/client/example/RefreshHFilesClient.java @@ -22,6 +22,8 @@ import java.io.Closeable; import java.io.IOException; import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.conf.Configured; +import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Connection; @@ -31,6 +33,8 @@ import org.apache.hadoop.hbase.ipc.CoprocessorRpcUtils.BlockingRpcCallback; import org.apache.hadoop.hbase.ipc.ServerRpcController; import org.apache.hadoop.hbase.protobuf.generated.RefreshHFilesProtos; +import org.apache.hadoop.util.Tool; +import org.apache.hadoop.util.ToolRunner; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -40,7 +44,7 @@ * Region Server side via the RefreshHFilesService. */ @InterfaceAudience.Private -public class RefreshHFilesClient implements Closeable { +public class RefreshHFilesClient extends Configured implements Tool, Closeable { private static final Logger LOG = LoggerFactory.getLogger(RefreshHFilesClient.class); private final Connection connection; @@ -93,4 +97,28 @@ public RefreshHFilesProtos.RefreshHFilesResponse call( }); LOG.debug("Done refreshing HFiles"); } + + @Override + public int run(String[] args) throws Exception { + if (args.length != 1) { + String message = "When there are multiple HBase clusters are sharing a common root dir, " + + "especially for read replica cluster (see detail in HBASE-18477), please consider to " + + "use this tool manually sync the flushed HFiles from the source cluster."; + message += "\nUsage: " + this.getClass().getName() + " tableName"; + System.out.println(message); + return -1; + } + final TableName tableName = TableName.valueOf(args[0]); + try { + refreshHFiles(tableName); + } catch (Throwable t) { + LOG.error("Refresh HFiles from table " + tableName.getNameAsString() + " failed: ", t); + return -1; + } + return 0; + } + + public static void main(String[] args) throws Exception { + ToolRunner.run(new RefreshHFilesClient(HBaseConfiguration.create()), args); + } } diff --git a/hbase-examples/src/test/java/org/apache/hadoop/hbase/client/example/TestRefreshHFilesClient.java b/hbase-examples/src/test/java/org/apache/hadoop/hbase/client/example/TestRefreshHFilesClient.java new file mode 100644 index 000000000000..b168db44b546 --- /dev/null +++ b/hbase-examples/src/test/java/org/apache/hadoop/hbase/client/example/TestRefreshHFilesClient.java @@ -0,0 +1,52 @@ +/** + * 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.client.example; + +import static org.junit.Assert.assertEquals; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.coprocessor.example.TestRefreshHFilesBase; +import org.apache.hadoop.hbase.regionserver.HRegion; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.util.ToolRunner; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({ ClientTests.class, MediumTests.class }) +public class TestRefreshHFilesClient extends TestRefreshHFilesBase { + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRefreshHFilesClient.class); + + @BeforeClass + public static void setUp() { + setUp(HRegion.class.getName()); + } + + @Test + public void testRefreshHFilesClient() throws Exception { + addHFilesToRegions(); + assertEquals(2, HTU.getNumHFiles(TABLE_NAME, FAMILY)); + RefreshHFilesClient tool = new RefreshHFilesClient(HTU.getConfiguration()); + assertEquals(0, ToolRunner.run(tool, new String[] { TABLE_NAME.getNameAsString() })); + assertEquals(4, HTU.getNumHFiles(TABLE_NAME, FAMILY)); + } +} diff --git a/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesBase.java b/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesBase.java new file mode 100644 index 000000000000..b948b62c600c --- /dev/null +++ b/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesBase.java @@ -0,0 +1,88 @@ +/** + * 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.coprocessor.example; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.MiniHBaseCluster; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; +import org.apache.hadoop.hbase.master.MasterFileSystem; +import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.FSUtils; +import org.apache.hadoop.hbase.util.HFileTestUtil; +import org.junit.After; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +public class TestRefreshHFilesBase { + protected static final Logger LOG = LoggerFactory.getLogger(TestRefreshHFilesBase.class); + protected static final HBaseTestingUtility HTU = new HBaseTestingUtility(); + protected static final int NUM_RS = 2; + protected static final TableName TABLE_NAME = TableName.valueOf("testRefreshRegionHFilesEP"); + protected static final byte[] FAMILY = Bytes.toBytes("family"); + protected static final byte[] QUALIFIER = Bytes.toBytes("qualifier"); + protected static final byte[][] SPLIT_KEY = new byte[][] { Bytes.toBytes("30") }; + protected static final int NUM_ROWS = 5; + protected static final String HFILE_NAME = "123abcdef"; + + protected static Configuration CONF = HTU.getConfiguration(); + protected static MiniHBaseCluster cluster; + protected static Table table; + + public static void setUp(String regionImpl) { + try { + CONF.set(HConstants.REGION_IMPL, regionImpl); + CONF.setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 2); + + CONF.setStrings(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, RefreshHFilesEndpoint.class.getName()); + cluster = HTU.startMiniCluster(NUM_RS); + + // Create table + table = HTU.createTable(TABLE_NAME, FAMILY, SPLIT_KEY); + + // this will create 2 regions spread across slaves + HTU.loadNumericRows(table, FAMILY, 1, 20); + HTU.flush(TABLE_NAME); + } catch (Exception ex) { + LOG.error("Couldn't finish setup", ex); + } + } + + @After + public void tearDown() throws Exception { + HTU.shutdownMiniCluster(); + } + + protected void addHFilesToRegions() throws IOException { + MasterFileSystem mfs = HTU.getMiniHBaseCluster().getMaster().getMasterFileSystem(); + Path tableDir = FSUtils.getTableDir(mfs.getRootDir(), TABLE_NAME); + for (Region region : cluster.getRegions(TABLE_NAME)) { + Path regionDir = new Path(tableDir, region.getRegionInfo().getEncodedName()); + Path familyDir = new Path(regionDir, Bytes.toString(FAMILY)); + HFileTestUtil + .createHFile(HTU.getConfiguration(), HTU.getTestFileSystem(), new Path(familyDir, HFILE_NAME), FAMILY, + QUALIFIER, Bytes.toBytes("50"), Bytes.toBytes("60"), NUM_ROWS); + } + } +} diff --git a/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesEndpoint.java b/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesEndpoint.java index d94210496f35..1a7c990fdd98 100644 --- a/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesEndpoint.java +++ b/hbase-examples/src/test/java/org/apache/hadoop/hbase/coprocessor/example/TestRefreshHFilesEndpoint.java @@ -27,92 +27,32 @@ import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.MiniHBaseCluster; -import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.RetriesExhaustedException; -import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.example.RefreshHFilesClient; -import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; -import org.apache.hadoop.hbase.master.MasterFileSystem; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HStore; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.RegionServerServices; import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.apache.hadoop.hbase.util.Bytes; -import org.apache.hadoop.hbase.util.FSUtils; -import org.apache.hadoop.hbase.util.HFileTestUtil; import org.apache.hadoop.hbase.wal.WAL; -import org.junit.After; import org.junit.ClassRule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; @Category(MediumTests.class) -public class TestRefreshHFilesEndpoint { +public class TestRefreshHFilesEndpoint extends TestRefreshHFilesBase { @ClassRule public static final HBaseClassTestRule CLASS_RULE = HBaseClassTestRule.forClass(TestRefreshHFilesEndpoint.class); - private static final Logger LOG = LoggerFactory.getLogger(TestRefreshHFilesEndpoint.class); - private static final HBaseTestingUtility HTU = new HBaseTestingUtility(); - private static final int NUM_RS = 2; - private static final TableName TABLE_NAME = TableName.valueOf("testRefreshRegionHFilesEP"); - private static final byte[] FAMILY = Bytes.toBytes("family"); - private static final byte[] QUALIFIER = Bytes.toBytes("qualifier"); - private static final byte[][] SPLIT_KEY = new byte[][] { Bytes.toBytes("30") }; - private static final int NUM_ROWS = 5; - private static final String HFILE_NAME = "123abcdef"; - - private static Configuration CONF = HTU.getConfiguration(); - private static MiniHBaseCluster cluster; - private static Table table; - - public static void setUp(String regionImpl) { - try { - CONF.set(HConstants.REGION_IMPL, regionImpl); - CONF.setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 2); - - CONF.setStrings(CoprocessorHost.REGION_COPROCESSOR_CONF_KEY, RefreshHFilesEndpoint.class.getName()); - cluster = HTU.startMiniCluster(NUM_RS); - - // Create table - table = HTU.createTable(TABLE_NAME, FAMILY, SPLIT_KEY); - - // this will create 2 regions spread across slaves - HTU.loadNumericRows(table, FAMILY, 1, 20); - HTU.flush(TABLE_NAME); - } catch (Exception ex) { - LOG.error("Couldn't finish setup", ex); - } - } - - @After - public void tearDown() throws Exception { - HTU.shutdownMiniCluster(); - } - @Test public void testRefreshRegionHFilesEndpoint() throws Exception { setUp(HRegion.class.getName()); - MasterFileSystem mfs = HTU.getMiniHBaseCluster().getMaster().getMasterFileSystem(); - Path tableDir = FSUtils.getTableDir(mfs.getRootDir(), TABLE_NAME); - for (Region region : cluster.getRegions(TABLE_NAME)) { - Path regionDir = new Path(tableDir, region.getRegionInfo().getEncodedName()); - Path familyDir = new Path(regionDir, Bytes.toString(FAMILY)); - HFileTestUtil - .createHFile(HTU.getConfiguration(), HTU.getTestFileSystem(), new Path(familyDir, HFILE_NAME), FAMILY, - QUALIFIER, Bytes.toBytes("50"), Bytes.toBytes("60"), NUM_ROWS); - } + addHFilesToRegions(); assertEquals(2, HTU.getNumHFiles(TABLE_NAME, FAMILY)); callRefreshRegionHFilesEndPoint(); assertEquals(4, HTU.getNumHFiles(TABLE_NAME, FAMILY)); diff --git a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSource.java b/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSource.java index 5add25f4c048..6b8c40ba5127 100644 --- a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSource.java +++ b/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSource.java @@ -41,6 +41,7 @@ public interface MetricsBalancerSource extends BaseSource { String BALANCE_CLUSTER = "balancerCluster"; String MISC_INVOATION_COUNT = "miscInvocationCount"; + String BALANCER_STATUS = "isBalancerActive"; /** * Description @@ -50,4 +51,6 @@ public interface MetricsBalancerSource extends BaseSource { void updateBalanceCluster(long time); void incrMiscInvocations(); + + void updateBalancerStatus(boolean status); } diff --git a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSource.java b/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSource.java index 10451138b4c3..61e94311563f 100644 --- a/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSource.java +++ b/hbase-hadoop-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSource.java @@ -53,6 +53,7 @@ public interface MetricsReplicationSourceSource extends BaseSource { public static final String SOURCE_REPEATED_LOG_FILE_BYTES = "source.repeatedLogFileBytes"; public static final String SOURCE_COMPLETED_LOGS = "source.completedLogs"; public static final String SOURCE_COMPLETED_RECOVERY_QUEUES = "source.completedRecoverQueues"; + public static final String SOURCE_FAILED_RECOVERY_QUEUES = "source.failedRecoverQueues"; void setLastShippedAge(long age); void incrSizeOfLogQueue(int size); @@ -76,4 +77,5 @@ public interface MetricsReplicationSourceSource extends BaseSource { void incrRepeatedFileBytes(final long bytes); void incrCompletedWAL(); void incrCompletedRecoveryQueue(); + void incrFailedRecoveryQueue(); } diff --git a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSourceImpl.java b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSourceImpl.java index a10b3d71ebdd..7bccbb70d584 100644 --- a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSourceImpl.java +++ b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancerSourceImpl.java @@ -36,6 +36,7 @@ public MetricsBalancerSourceImpl(String metricsName, String metricsDescription, String metricsContext, String metricsJmxContext) { super(metricsName, metricsDescription, metricsContext, metricsJmxContext); + updateBalancerStatus(true); } @Override @@ -53,4 +54,9 @@ public void updateBalanceCluster(long time) { public void incrMiscInvocations() { miscCount.incr(); } + + @Override + public void updateBalancerStatus(boolean status) { + metricsRegistry.tag(BALANCER_STATUS,"", String.valueOf(status), true); + } } diff --git a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationGlobalSourceSource.java b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationGlobalSourceSource.java index 9a86cf2f9e45..4e8c810138be 100644 --- a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationGlobalSourceSource.java +++ b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationGlobalSourceSource.java @@ -52,6 +52,7 @@ public class MetricsReplicationGlobalSourceSource implements MetricsReplicationS private final MutableFastCounter repeatedFileBytes; private final MutableFastCounter completedWAL; private final MutableFastCounter completedRecoveryQueue; + private final MutableFastCounter failedRecoveryQueue; public MetricsReplicationGlobalSourceSource(MetricsReplicationSourceImpl rms) { this.rms = rms; @@ -89,6 +90,8 @@ public MetricsReplicationGlobalSourceSource(MetricsReplicationSourceImpl rms) { completedWAL = rms.getMetricsRegistry().getCounter(SOURCE_COMPLETED_LOGS, 0L); completedRecoveryQueue = rms.getMetricsRegistry() .getCounter(SOURCE_COMPLETED_RECOVERY_QUEUES, 0L); + failedRecoveryQueue = rms.getMetricsRegistry() + .getCounter(SOURCE_FAILED_RECOVERY_QUEUES, 0L); } @Override public void setLastShippedAge(long age) { @@ -199,7 +202,10 @@ public void incrCompletedWAL() { public void incrCompletedRecoveryQueue() { completedRecoveryQueue.incr(1L); } - + @Override + public void incrFailedRecoveryQueue() { + failedRecoveryQueue.incr(1L); + } @Override public void init() { rms.init(); diff --git a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSourceImpl.java b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSourceImpl.java index 719c91631d26..0ad50524f152 100644 --- a/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSourceImpl.java +++ b/hbase-hadoop2-compat/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsReplicationSourceSourceImpl.java @@ -257,6 +257,9 @@ public void incrCompletedRecoveryQueue() { completedRecoveryQueue.incr(1L); } + @Override + public void incrFailedRecoveryQueue() {/*no op*/} + @Override public void init() { rms.init(); diff --git a/hbase-http/pom.xml b/hbase-http/pom.xml index 667b3f58872e..fb704511cc9c 100644 --- a/hbase-http/pom.xml +++ b/hbase-http/pom.xml @@ -263,7 +263,7 @@ org.bouncycastle - bcprov-jdk16 + bcprov-jdk15on test diff --git a/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/Action.java b/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/Action.java index 350e18a4544a..6db6da0a3dbf 100644 --- a/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/Action.java +++ b/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/Action.java @@ -21,9 +21,11 @@ import java.io.IOException; import java.util.ArrayList; import java.util.Collection; +import java.util.HashSet; import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Set; import java.util.function.BiConsumer; import java.util.function.Consumer; @@ -139,16 +141,13 @@ protected ServerName[] getCurrentServers() throws IOException { return new ServerName [] {}; } ServerName master = clusterStatus.getMasterName(); - if (master == null || !regionServers.contains(master)) { - return regionServers.toArray(new ServerName[count]); - } - if (count == 1) { - return new ServerName [] {}; - } + Set masters = new HashSet(); + masters.add(master); + masters.addAll(clusterStatus.getBackupMasterNames()); ArrayList tmp = new ArrayList<>(count); tmp.addAll(regionServers); - tmp.remove(master); - return tmp.toArray(new ServerName[count-1]); + tmp.removeAll(masters); + return tmp.toArray(new ServerName[tmp.size()]); } protected void killMaster(ServerName server) throws IOException { diff --git a/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/ChangeBloomFilterAction.java b/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/ChangeBloomFilterAction.java index 47ef6489df1c..4faf05df98c1 100644 --- a/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/ChangeBloomFilterAction.java +++ b/hbase-it/src/test/java/org/apache/hadoop/hbase/chaos/actions/ChangeBloomFilterAction.java @@ -22,6 +22,7 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.regionserver.BloomType; +import org.apache.hadoop.hbase.util.BloomFilterUtil; /** * Action that tries to adjust the bloom filter setting on all the columns of a @@ -53,6 +54,11 @@ public void perform() throws Exception { LOG.debug("Performing action: About to set bloom filter type to " + bloomType + " on column " + columnName + " of table " + tableName); columnBuilder.setBloomFilterType(bloomType); + if (bloomType == BloomType.ROWPREFIX_FIXED_LENGTH) { + columnBuilder.setConfiguration(BloomFilterUtil.PREFIX_LENGTH_KEY, "10"); + } else if (bloomType == BloomType.ROWPREFIX_DELIMITED) { + columnBuilder.setConfiguration(BloomFilterUtil.DELIMITER_KEY, "#"); + } }); LOG.debug("Performing action: Just set bloom filter types on table " + tableName); diff --git a/hbase-it/src/test/java/org/apache/hadoop/hbase/test/IntegrationTestBigLinkedList.java b/hbase-it/src/test/java/org/apache/hadoop/hbase/test/IntegrationTestBigLinkedList.java index 35bc7a1a42a6..b965bcab68c6 100644 --- a/hbase-it/src/test/java/org/apache/hadoop/hbase/test/IntegrationTestBigLinkedList.java +++ b/hbase-it/src/test/java/org/apache/hadoop/hbase/test/IntegrationTestBigLinkedList.java @@ -15,7 +15,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.test; import java.io.DataInput; @@ -58,6 +57,7 @@ import org.apache.hadoop.hbase.client.BufferedMutator; import org.apache.hadoop.hbase.client.BufferedMutatorParams; import org.apache.hadoop.hbase.client.Connection; +import org.apache.hadoop.hbase.client.ConnectionConfiguration; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Mutation; @@ -79,6 +79,7 @@ import org.apache.hadoop.hbase.testclassification.IntegrationTests; import org.apache.hadoop.hbase.util.AbstractHBaseTool; import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.Random64; import org.apache.hadoop.hbase.util.RegionSplitter; import org.apache.hadoop.hbase.wal.WALEdit; import org.apache.hadoop.hbase.wal.WALKey; @@ -113,6 +114,8 @@ import org.junit.experimental.categories.Category; import org.slf4j.Logger; import org.slf4j.LoggerFactory; + +import org.apache.hbase.thirdparty.com.google.common.base.Preconditions; import org.apache.hbase.thirdparty.com.google.common.collect.Sets; import org.apache.hbase.thirdparty.org.apache.commons.cli.CommandLine; import org.apache.hbase.thirdparty.org.apache.commons.cli.GnuParser; @@ -267,6 +270,15 @@ static class Generator extends Configured implements Tool { public static final String MULTIPLE_UNEVEN_COLUMNFAMILIES_KEY = "generator.multiple.columnfamilies"; + /** + * Set this configuration if you want to scale up the size of test data quickly. + *

+ * $ ./bin/hbase org.apache.hadoop.hbase.test.IntegrationTestBigLinkedList + * -Dgenerator.big.family.value.size=1024 generator 1 10 output + */ + public static final String BIG_FAMILY_VALUE_SIZE_KEY = "generator.big.family.value.size"; + + public static enum Counts { SUCCESS, TERMINATING, UNDEFINED, IOEXCEPTION } @@ -300,7 +312,7 @@ public void write(DataOutput arg0) throws IOException { static class GeneratorRecordReader extends RecordReader { private long count; private long numNodes; - private Random rand; + private Random64 rand; @Override public void close() throws IOException { @@ -327,8 +339,8 @@ public float getProgress() throws IOException, InterruptedException { public void initialize(InputSplit arg0, TaskAttemptContext context) throws IOException, InterruptedException { numNodes = context.getConfiguration().getLong(GENERATOR_NUM_ROWS_PER_MAP_KEY, 25000000); - // Use SecureRandom to avoid issue described in HBASE-13382. - rand = new SecureRandom(); + // Use Random64 to avoid issue described in HBASE-21256. + rand = new Random64(); } @Override @@ -437,6 +449,36 @@ protected void setup(Context context) throws IOException, InterruptedException { this.numWalkers = context.getConfiguration().getInt(CONCURRENT_WALKER_KEY, CONCURRENT_WALKER_DEFAULT); this.walkersStop = false; this.conf = context.getConfiguration(); + + if (multipleUnevenColumnFamilies) { + int n = context.getConfiguration().getInt(BIG_FAMILY_VALUE_SIZE_KEY, 256); + int limit = context.getConfiguration().getInt( + ConnectionConfiguration.MAX_KEYVALUE_SIZE_KEY, + ConnectionConfiguration.MAX_KEYVALUE_SIZE_DEFAULT); + + Preconditions.checkArgument( + n <= limit, + "%s(%s) > %s(%s)", + BIG_FAMILY_VALUE_SIZE_KEY, n, ConnectionConfiguration.MAX_KEYVALUE_SIZE_KEY, limit); + + bigValue = new byte[n]; + ThreadLocalRandom.current().nextBytes(bigValue); + LOG.info("Create a bigValue with " + n + " bytes."); + } + + Preconditions.checkArgument( + numNodes > 0, + "numNodes(%s) <= 0", + numNodes); + Preconditions.checkArgument( + numNodes % width == 0, + "numNodes(%s) mod width(%s) != 0", + numNodes, width); + Preconditions.checkArgument( + numNodes % wrap == 0, + "numNodes(%s) mod wrap(%s) != 0", + numNodes, wrap + ); } protected void instantiateHTable() throws IOException { @@ -457,9 +499,8 @@ protected void map(BytesWritable key, NullWritable value, Context output) throws current[i] = new byte[key.getLength()]; System.arraycopy(key.getBytes(), 0, current[i], 0, key.getLength()); if (++i == current.length) { - LOG.info("Persisting current.length=" + current.length + ", count=" + count + ", id=" + - Bytes.toStringBinary(id) + ", current=" + Bytes.toStringBinary(current[0]) + - ", i=" + i); + LOG.debug("Persisting current.length={}, count={}, id={}, current={}, i=", + current.length, count, Bytes.toStringBinary(id), Bytes.toStringBinary(current[0]), i); persist(output, count, prev, current, id); i = 0; @@ -526,11 +567,6 @@ protected void persist(Context output, long count, byte[][] prev, byte[][] curre if (this.multipleUnevenColumnFamilies) { // Use any column name. put.addColumn(TINY_FAMILY_NAME, TINY_FAMILY_NAME, this.tinyValue); - // If we've not allocated bigValue, do it now. Reuse same value each time. - if (this.bigValue == null) { - this.bigValue = new byte[current[i].length * 10]; - ThreadLocalRandom.current().nextBytes(this.bigValue); - } // Use any column name. put.addColumn(BIG_FAMILY_NAME, BIG_FAMILY_NAME, this.bigValue); } @@ -759,6 +795,7 @@ public int runRandomInputGenerator(int numMappers, long numNodes, Path tmpOutput FileOutputFormat.setOutputPath(job, tmpOutput); job.setOutputFormatClass(SequenceFileOutputFormat.class); + TableMapReduceUtil.addDependencyJarsForClasses(job.getConfiguration(), Random64.class); boolean success = jobCompletion(job); @@ -1155,13 +1192,14 @@ public void reduce(BytesWritable key, Iterable values, Context co // TODO check for more than one def, should not happen StringBuilder refsSb = null; - String keyString = Bytes.toStringBinary(key.getBytes(), 0, key.getLength()); if (defCount == 0 || refs.size() != 1) { + String keyString = Bytes.toStringBinary(key.getBytes(), 0, key.getLength()); refsSb = dumpExtraInfoOnRefs(key, context, refs); LOG.error("LinkedListError: key=" + keyString + ", reference(s)=" + (refsSb != null? refsSb.toString(): "")); } if (lostFamilies) { + String keyString = Bytes.toStringBinary(key.getBytes(), 0, key.getLength()); LOG.error("LinkedListError: key=" + keyString + ", lost big or tiny families"); context.getCounter(Counts.LOST_FAMILIES).increment(1); context.write(key, LOSTFAM); @@ -1188,6 +1226,7 @@ public void reduce(BytesWritable key, Iterable values, Context co // was added which can help a little debugging. This info is only available in mapper // output -- the 'Linked List error Key...' log message above. What we emit here is // useless for debugging. + String keyString = Bytes.toStringBinary(key.getBytes(), 0, key.getLength()); context.getCounter("undef", keyString).increment(1); } } else if (defCount > 0 && refs.isEmpty()) { @@ -1195,6 +1234,7 @@ public void reduce(BytesWritable key, Iterable values, Context co context.write(key, UNREF); context.getCounter(Counts.UNREFERENCED).increment(1); if (rows.addAndGet(1) < MISSING_ROWS_TO_LOG) { + String keyString = Bytes.toStringBinary(key.getBytes(), 0, key.getLength()); context.getCounter("unref", keyString).increment(1); } } else { diff --git a/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java b/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java index 0063c56a993f..c911e8c8677a 100644 --- a/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java +++ b/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/HFileOutputFormat2.java @@ -73,6 +73,7 @@ import org.apache.hadoop.hbase.regionserver.BloomType; import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.regionserver.StoreFileWriter; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.util.FSUtils; @@ -149,6 +150,8 @@ protected static byte[] combineTableNameSuffix(byte[] tableName, byte[] suffix) "hbase.hfileoutputformat.families.compression"; static final String BLOOM_TYPE_FAMILIES_CONF_KEY = "hbase.hfileoutputformat.families.bloomtype"; + static final String BLOOM_PARAM_FAMILIES_CONF_KEY = + "hbase.hfileoutputformat.families.bloomparam"; static final String BLOCK_SIZE_FAMILIES_CONF_KEY = "hbase.mapreduce.hfileoutputformat.blocksize"; static final String DATABLOCK_ENCODING_FAMILIES_CONF_KEY = @@ -216,6 +219,7 @@ protected static byte[] getTableNameSuffixedWithFamily(byte[] tableName, byte[] // create a map from column family to the compression algorithm final Map compressionMap = createFamilyCompressionMap(conf); final Map bloomTypeMap = createFamilyBloomTypeMap(conf); + final Map bloomParamMap = createFamilyBloomParamMap(conf); final Map blockSizeMap = createFamilyBlockSizeMap(conf); String dataBlockEncodingStr = conf.get(DATABLOCK_ENCODING_OVERRIDE_CONF_KEY); @@ -399,6 +403,12 @@ private WriterLength getNewWriter(byte[] tableName, byte[] family, Configuration compression = compression == null ? defaultCompression : compression; BloomType bloomType = bloomTypeMap.get(tableAndFamily); bloomType = bloomType == null ? BloomType.NONE : bloomType; + String bloomParam = bloomParamMap.get(tableAndFamily); + if (bloomType == BloomType.ROWPREFIX_FIXED_LENGTH) { + conf.set(BloomFilterUtil.PREFIX_LENGTH_KEY, bloomParam); + } else if (bloomType == BloomType.ROWPREFIX_DELIMITED) { + conf.set(BloomFilterUtil.DELIMITER_KEY, bloomParam); + } Integer blockSize = blockSizeMap.get(tableAndFamily); blockSize = blockSize == null ? HConstants.DEFAULT_BLOCKSIZE : blockSize; DataBlockEncoding encoding = overriddenEncoding; @@ -667,6 +677,8 @@ static void configureIncrementalLoad(Job job, List multiTableInfo, tableDescriptors)); conf.set(BLOOM_TYPE_FAMILIES_CONF_KEY, serializeColumnFamilyAttribute(bloomTypeDetails, tableDescriptors)); + conf.set(BLOOM_PARAM_FAMILIES_CONF_KEY, serializeColumnFamilyAttribute(bloomParamDetails, + tableDescriptors)); conf.set(DATABLOCK_ENCODING_FAMILIES_CONF_KEY, serializeColumnFamilyAttribute(dataBlockEncodingDetails, tableDescriptors)); @@ -694,6 +706,8 @@ public static void configureIncrementalLoadMap(Job job, TableDescriptor tableDes serializeColumnFamilyAttribute(blockSizeDetails, singleTableDescriptor)); conf.set(BLOOM_TYPE_FAMILIES_CONF_KEY, serializeColumnFamilyAttribute(bloomTypeDetails, singleTableDescriptor)); + conf.set(BLOOM_PARAM_FAMILIES_CONF_KEY, + serializeColumnFamilyAttribute(bloomParamDetails, singleTableDescriptor)); conf.set(DATABLOCK_ENCODING_FAMILIES_CONF_KEY, serializeColumnFamilyAttribute(dataBlockEncodingDetails, singleTableDescriptor)); @@ -741,6 +755,19 @@ static Map createFamilyBloomTypeMap(Configuration conf) { return bloomTypeMap; } + /** + * Runs inside the task to deserialize column family to bloom filter param + * map from the configuration. + * + * @param conf to read the serialized values from + * @return a map from column family to the the configured bloom filter param + */ + @VisibleForTesting + static Map createFamilyBloomParamMap(Configuration conf) { + return createFamilyConfValueMap(conf, BLOOM_PARAM_FAMILIES_CONF_KEY); + } + + /** * Runs inside the task to deserialize column family to block size * map from the configuration. @@ -908,6 +935,30 @@ static String serializeColumnFamilyAttribute(Function bloomParamDetails = familyDescriptor -> { + BloomType bloomType = familyDescriptor.getBloomFilterType(); + String bloomParam = ""; + if (bloomType == BloomType.ROWPREFIX_FIXED_LENGTH) { + bloomParam = familyDescriptor.getConfigurationValue(BloomFilterUtil.PREFIX_LENGTH_KEY); + } else if (bloomType == BloomType.ROWPREFIX_DELIMITED) { + bloomParam = familyDescriptor.getConfigurationValue(BloomFilterUtil.DELIMITER_KEY); + } + return bloomParam; + }; + /** * Serialize column family to data block encoding map to configuration. * Invoked while configuring the MR job for incremental load. diff --git a/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/replication/VerifyReplication.java b/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/replication/VerifyReplication.java index d1b5c607fbd3..d5f8215d523f 100644 --- a/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/replication/VerifyReplication.java +++ b/hbase-mapreduce/src/main/java/org/apache/hadoop/hbase/mapreduce/replication/VerifyReplication.java @@ -352,7 +352,7 @@ public boolean isAborted() { return Pair.newPair(peerConfig, ReplicationUtils.getPeerClusterConfiguration(peerConfig, conf)); } catch (ReplicationException e) { - throw new IOException("An error occurred while trying to connect to the remove peer cluster", + throw new IOException("An error occurred while trying to connect to the remote peer cluster", e); } finally { if (localZKW != null) { diff --git a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestCopyTable.java b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestCopyTable.java index 6f416710e1ee..ed6857dd3b6a 100644 --- a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestCopyTable.java +++ b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/mapreduce/TestCopyTable.java @@ -30,15 +30,20 @@ import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.client.TableDescriptorBuilder; +import org.apache.hadoop.hbase.mob.MobTestUtil; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MapReduceTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.LauncherSecurityManager; import org.apache.hadoop.util.ToolRunner; + import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -100,7 +105,7 @@ private void doCopyTableTest(boolean bulkload) throws Exception { if (bulkload) { code = ToolRunner.run(new Configuration(TEST_UTIL.getConfiguration()), copy, new String[] { "--new.name=" + tableName2.getNameAsString(), - "--bulkload", tableName1.getNameAsString() }); + "--bulkload", tableName1.getNameAsString() }); } else { code = ToolRunner.run(new Configuration(TEST_UTIL.getConfiguration()), copy, new String[] { "--new.name=" + tableName2.getNameAsString(), @@ -121,9 +126,74 @@ private void doCopyTableTest(boolean bulkload) throws Exception { } } + private void doCopyTableTestWithMob(boolean bulkload) throws Exception { + final TableName tableName1 = TableName.valueOf(name.getMethodName() + "1"); + final TableName tableName2 = TableName.valueOf(name.getMethodName() + "2"); + final byte[] FAMILY = Bytes.toBytes("mob"); + final byte[] COLUMN1 = Bytes.toBytes("c1"); + + ColumnFamilyDescriptorBuilder cfd = ColumnFamilyDescriptorBuilder.newBuilder(FAMILY); + + cfd.setMobEnabled(true); + cfd.setMobThreshold(5); + TableDescriptor desc1 = TableDescriptorBuilder.newBuilder(tableName1) + .setColumnFamily(cfd.build()) + .build(); + TableDescriptor desc2 = TableDescriptorBuilder.newBuilder(tableName2) + .setColumnFamily(cfd.build()) + .build(); + + try (Table t1 = TEST_UTIL.createTable(desc1, null); + Table t2 = TEST_UTIL.createTable(desc2, null);) { + + // put rows into the first table + for (int i = 0; i < 10; i++) { + Put p = new Put(Bytes.toBytes("row" + i)); + p.addColumn(FAMILY, COLUMN1, COLUMN1); + t1.put(p); + } + + CopyTable copy = new CopyTable(); + + int code; + if (bulkload) { + code = ToolRunner.run(new Configuration(TEST_UTIL.getConfiguration()), + copy, new String[] { "--new.name=" + tableName2.getNameAsString(), + "--bulkload", tableName1.getNameAsString() }); + } else { + code = ToolRunner.run(new Configuration(TEST_UTIL.getConfiguration()), + copy, new String[] { "--new.name=" + tableName2.getNameAsString(), + tableName1.getNameAsString() }); + } + assertEquals("copy job failed", 0, code); + + // verify the data was copied into table 2 + for (int i = 0; i < 10; i++) { + Get g = new Get(Bytes.toBytes("row" + i)); + Result r = t2.get(g); + assertEquals(1, r.size()); + assertTrue(CellUtil.matchingQualifier(r.rawCells()[0], COLUMN1)); + assertEquals("compare row values between two tables", + t1.getDescriptor().getValue("row" + i), + t2.getDescriptor().getValue("row" + i)); + } + + assertEquals("compare count of mob rows after table copy", MobTestUtil.countMobRows(t1), + MobTestUtil.countMobRows(t2)); + assertEquals("compare count of mob row values between two tables", + t1.getDescriptor().getValues().size(), + t2.getDescriptor().getValues().size()); + assertTrue("The mob row count is 0 but should be > 0", + MobTestUtil.countMobRows(t2) > 0); + + } finally { + TEST_UTIL.deleteTable(tableName1); + TEST_UTIL.deleteTable(tableName2); + } + } + /** * Simple end-to-end test - * @throws Exception */ @Test public void testCopyTable() throws Exception { @@ -138,56 +208,70 @@ public void testCopyTableWithBulkload() throws Exception { doCopyTableTest(true); } + /** + * Simple end-to-end test on table with MOB + */ + @Test + public void testCopyTableWithMob() throws Exception { + doCopyTableTestWithMob(false); + } + + /** + * Simple end-to-end test with bulkload on table with MOB. + */ + @Test + public void testCopyTableWithBulkloadWithMob() throws Exception { + doCopyTableTestWithMob(true); + } + @Test public void testStartStopRow() throws Exception { final TableName tableName1 = TableName.valueOf(name.getMethodName() + "1"); final TableName tableName2 = TableName.valueOf(name.getMethodName() + "2"); final byte[] FAMILY = Bytes.toBytes("family"); final byte[] COLUMN1 = Bytes.toBytes("c1"); - final byte[] ROW0 = Bytes.toBytesBinary("\\x01row0"); - final byte[] ROW1 = Bytes.toBytesBinary("\\x01row1"); - final byte[] ROW2 = Bytes.toBytesBinary("\\x01row2"); - - Table t1 = TEST_UTIL.createTable(tableName1, FAMILY); - Table t2 = TEST_UTIL.createTable(tableName2, FAMILY); - - // put rows into the first table - Put p = new Put(ROW0); - p.addColumn(FAMILY, COLUMN1, COLUMN1); - t1.put(p); - p = new Put(ROW1); - p.addColumn(FAMILY, COLUMN1, COLUMN1); - t1.put(p); - p = new Put(ROW2); - p.addColumn(FAMILY, COLUMN1, COLUMN1); - t1.put(p); - - CopyTable copy = new CopyTable(); - assertEquals( - 0, - ToolRunner.run(new Configuration(TEST_UTIL.getConfiguration()), - copy, new String[] { "--new.name=" + tableName2, "--startrow=\\x01row1", - "--stoprow=\\x01row2", tableName1.getNameAsString() })); - - // verify the data was copied into table 2 - // row1 exist, row0, row2 do not exist - Get g = new Get(ROW1); - Result r = t2.get(g); - assertEquals(1, r.size()); - assertTrue(CellUtil.matchingQualifier(r.rawCells()[0], COLUMN1)); - - g = new Get(ROW0); - r = t2.get(g); - assertEquals(0, r.size()); - - g = new Get(ROW2); - r = t2.get(g); - assertEquals(0, r.size()); - - t1.close(); - t2.close(); - TEST_UTIL.deleteTable(tableName1); - TEST_UTIL.deleteTable(tableName2); + final byte[] row0 = Bytes.toBytesBinary("\\x01row0"); + final byte[] row1 = Bytes.toBytesBinary("\\x01row1"); + final byte[] row2 = Bytes.toBytesBinary("\\x01row2"); + + try (Table t1 = TEST_UTIL.createTable(tableName1, FAMILY); + Table t2 = TEST_UTIL.createTable(tableName2, FAMILY)) { + + // put rows into the first table + Put p = new Put(row0); + p.addColumn(FAMILY, COLUMN1, COLUMN1); + t1.put(p); + p = new Put(row1); + p.addColumn(FAMILY, COLUMN1, COLUMN1); + t1.put(p); + p = new Put(row2); + p.addColumn(FAMILY, COLUMN1, COLUMN1); + t1.put(p); + + CopyTable copy = new CopyTable(); + assertEquals(0, ToolRunner.run(new Configuration(TEST_UTIL.getConfiguration()), + copy, new String[]{"--new.name=" + tableName2, "--startrow=\\x01row1", + "--stoprow=\\x01row2", tableName1.getNameAsString()})); + + // verify the data was copied into table 2 + // row1 exist, row0, row2 do not exist + Get g = new Get(row1); + Result r = t2.get(g); + assertEquals(1, r.size()); + assertTrue(CellUtil.matchingQualifier(r.rawCells()[0], COLUMN1)); + + g = new Get(row0); + r = t2.get(g); + assertEquals(0, r.size()); + + g = new Get(row2); + r = t2.get(g); + assertEquals(0, r.size()); + + } finally { + TEST_UTIL.deleteTable(tableName1); + TEST_UTIL.deleteTable(tableName2); + } } /** @@ -215,8 +299,8 @@ public void testRenameFamily() throws Exception { long currentTime = System.currentTimeMillis(); String[] args = new String[] { "--new.name=" + targetTable, "--families=a:b", "--all.cells", - "--starttime=" + (currentTime - 100000), "--endtime=" + (currentTime + 100000), - "--versions=1", sourceTable.getNameAsString() }; + "--starttime=" + (currentTime - 100000), "--endtime=" + (currentTime + 100000), + "--versions=1", sourceTable.getNameAsString() }; assertNull(t2.get(new Get(ROW1)).getRow()); assertTrue(runCopy(args)); diff --git a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/util/LoadTestTool.java b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/util/LoadTestTool.java index f4f483e847f9..f0e04c4d603f 100644 --- a/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/util/LoadTestTool.java +++ b/hbase-mapreduce/src/test/java/org/apache/hadoop/hbase/util/LoadTestTool.java @@ -119,6 +119,7 @@ public class LoadTestTool extends AbstractHBaseTool { protected static final String OPT_VERBOSE = "verbose"; public static final String OPT_BLOOM = "bloom"; + public static final String OPT_BLOOM_PARAM = "bloom_param"; public static final String OPT_COMPRESSION = "compression"; public static final String OPT_DEFERRED_LOG_FLUSH = "deferredlogflush"; public static final String OPT_DEFERRED_LOG_FLUSH_USAGE = "Enable deferred log flush."; @@ -330,6 +331,7 @@ protected void addOptions() { addOptWithArg(OPT_UPDATE, OPT_USAGE_UPDATE); addOptNoArg(OPT_INIT_ONLY, "Initialize the test table only, don't do any loading"); addOptWithArg(OPT_BLOOM, OPT_USAGE_BLOOM); + addOptWithArg(OPT_BLOOM_PARAM, "the parameter of bloom filter type"); addOptWithArg(OPT_COMPRESSION, OPT_USAGE_COMPRESSION); addOptWithArg(HFileTestUtil.OPT_DATA_BLOCK_ENCODING, HFileTestUtil.OPT_DATA_BLOCK_ENCODING_USAGE); addOptWithArg(OPT_MAX_READ_ERRORS, "The maximum number of read errors " + @@ -551,6 +553,22 @@ private void parseColumnFamilyOptions(CommandLine cmd) { bloomType = bloomStr == null ? BloomType.ROW : BloomType.valueOf(bloomStr); + if (bloomType == BloomType.ROWPREFIX_FIXED_LENGTH) { + if (!cmd.hasOption(OPT_BLOOM_PARAM)) { + LOG.error("the parameter of bloom filter {} is not specified", bloomType.name()); + } else { + conf.set(BloomFilterUtil.PREFIX_LENGTH_KEY, cmd.getOptionValue(OPT_BLOOM_PARAM)); + } + } + + if (bloomType == BloomType.ROWPREFIX_DELIMITED) { + if (!cmd.hasOption(OPT_BLOOM_PARAM)) { + LOG.error("the parameter of bloom filter {} is not specified", bloomType.name()); + } else { + conf.set(BloomFilterUtil.DELIMITER_KEY, cmd.getOptionValue(OPT_BLOOM_PARAM)); + } + } + inMemoryCF = cmd.hasOption(OPT_INMEMORY); if (cmd.hasOption(OPT_ENCRYPTION)) { cipher = Encryption.getCipher(conf, cmd.getOptionValue(OPT_ENCRYPTION)); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/AbstractProcedureScheduler.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/AbstractProcedureScheduler.java index 5645f89e14d7..7ab1329b32b7 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/AbstractProcedureScheduler.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/AbstractProcedureScheduler.java @@ -85,6 +85,11 @@ public void addFront(final Procedure procedure) { push(procedure, true, true); } + @Override + public void addFront(final Procedure procedure, boolean notify) { + push(procedure, true, notify); + } + @Override public void addFront(Iterator procedureIterator) { schedLock(); @@ -109,6 +114,11 @@ public void addBack(final Procedure procedure) { push(procedure, false, true); } + @Override + public void addBack(final Procedure procedure, boolean notify) { + push(procedure, false, notify); + } + protected void push(final Procedure procedure, final boolean addFront, final boolean notify) { schedLock(); try { diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/LockAndQueue.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/LockAndQueue.java index ae8daa283147..4365a2c1950f 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/LockAndQueue.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/LockAndQueue.java @@ -73,7 +73,8 @@ public boolean isLockOwner(long procId) { @Override public boolean hasParentLock(Procedure proc) { - // TODO: need to check all the ancestors + // TODO: need to check all the ancestors. need to passed in the procedures + // to find the ancestors. return proc.hasParent() && (isLockOwner(proc.getParentProcId()) || isLockOwner(proc.getRootProcId())); } diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/Procedure.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/Procedure.java index 393bd2fa2c63..a85ccb12925f 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/Procedure.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/Procedure.java @@ -145,31 +145,64 @@ public enum LockState { private boolean lockedWhenLoading = false; /** - * Used for force complete of the procedure without - * actually doing any logic in the procedure. + * Used for override complete of the procedure without actually doing any logic in the procedure. * If bypass is set to true, when executing it will return null when - * {@link #doExecute(Object)} to finish the procedure and releasing any locks - * it may currently hold. - * Bypassing a procedure is not like aborting. Aborting a procedure will trigger + * {@link #doExecute(Object)} is called to finish the procedure and release any locks + * it may currently hold. The bypass does cleanup around the Procedure as far as the + * Procedure framework is concerned. It does not clean any internal state that the + * Procedure's themselves may have set. That is for the Procedures to do themselves + * when bypass is called. They should override bypass and do their cleanup in the + * overridden bypass method (be sure to call the parent bypass to ensure proper + * processing). + *

Bypassing a procedure is not like aborting. Aborting a procedure will trigger * a rollback. And since the {@link #abort(Object)} method is overrideable * Some procedures may have chosen to ignore the aborting. */ private volatile boolean bypass = false; + /** + * Indicate whether we need to persist the procedure to ProcedureStore after execution. Default to + * true, and the implementation can all {@link #skipPersistence()} to let the framework skip the + * persistence of the procedure. + *

+ * This is useful when the procedure is in error and you want to retry later. The retry interval + * and the number of retries are usually not critical so skip the persistence can save some + * resources, and also speed up the restart processing. + *

+ * Notice that this value will be reset to true every time before execution. And when rolling back + * we do not test this value. + */ + private boolean persist = true; + public boolean isBypass() { return bypass; } /** - * set the bypass to true - * Only called in {@link ProcedureExecutor#bypassProcedure(long, long, boolean)} for now, - * DO NOT use this method alone, since we can't just bypass - * one single procedure. We need to bypass its ancestor too. So making it package private + * Set the bypass to true. + * Only called in {@link ProcedureExecutor#bypassProcedure(long, long, boolean, boolean)} for now. + * DO NOT use this method alone, since we can't just bypass one single procedure. We need to + * bypass its ancestor too. If your Procedure has set state, it needs to undo it in here. + * @param env Current environment. May be null because of context; e.g. pretty-printing + * procedure WALs where there is no 'environment' (and where Procedures that require + * an 'environment' won't be run. */ - void bypass() { + protected void bypass(TEnvironment env) { this.bypass = true; } + boolean needPersistence() { + return persist; + } + + void resetPersistence() { + persist = true; + } + + protected final void skipPersistence() { + persist = false; + } + /** * The main code of the procedure. It must be idempotent since execute() * may be called multiple times in case of machine failure in the middle @@ -296,7 +329,8 @@ protected boolean holdLock(TEnvironment env) { * @see #holdLock(Object) * @return true if the procedure has the lock, false otherwise. */ - protected final boolean hasLock() { + @VisibleForTesting + public final boolean hasLock() { return locked; } @@ -677,12 +711,16 @@ protected void setResult(byte[] result) { /** * Will only be called when loading procedures from procedure store, where we need to record * whether the procedure has already held a lock. Later we will call - * {@link #doAcquireLock(Object)} to actually acquire the lock. + * {@link #doAcquireLock(Object, ProcedureStore)} to actually acquire the lock. */ final void lockedWhenLoading() { this.lockedWhenLoading = true; } + public boolean isLockedWhenLoading() { + return lockedWhenLoading; + } + // ============================================================================================== // Runtime state, updated every operation by the ProcedureExecutor // @@ -949,7 +987,13 @@ final void restoreLock(TEnvironment env) { LOG.debug("{} is already bypassed, skip acquiring lock.", this); return; } - + // this can happen if the parent stores the sub procedures but before it can + // release its lock, the master restarts + if (getState() == ProcedureState.WAITING && !holdLock(env)) { + LOG.debug("{} is in WAITING STATE, and holdLock= false, skip acquiring lock.", this); + lockedWhenLoading = false; + return; + } LOG.debug("{} held the lock before restarting, call acquireLock to restore it.", this); LockState state = acquireLock(env); assert state == LockState.LOCK_ACQUIRED; diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureExecutor.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureExecutor.java index e398fa4f292f..01d2b2b501a3 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureExecutor.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureExecutor.java @@ -15,7 +15,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2; import java.io.IOException; @@ -32,6 +31,8 @@ import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.CopyOnWriteArrayList; +import java.util.concurrent.Executor; +import java.util.concurrent.Executors; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; @@ -45,6 +46,7 @@ import org.apache.hadoop.hbase.procedure2.Procedure.LockState; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureIterator; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureStoreListener; import org.apache.hadoop.hbase.procedure2.util.StringUtils; import org.apache.hadoop.hbase.security.User; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; @@ -57,6 +59,7 @@ import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.hbase.thirdparty.com.google.common.base.Preconditions; +import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ThreadFactoryBuilder; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; @@ -315,7 +318,7 @@ protected void periodicExecute(final TEnvironment env) { private Configuration conf; /** - * Created in the {@link #start(int, boolean)} method. Destroyed in {@link #join()} (FIX! Doing + * Created in the {@link #init(int, boolean)} method. Destroyed in {@link #join()} (FIX! Doing * resource handling rather than observing in a #join is unexpected). * Overridden when we do the ProcedureTestingUtility.testRecoveryAndDoubleExecution trickery * (Should be ok). @@ -323,7 +326,7 @@ protected void periodicExecute(final TEnvironment env) { private ThreadGroup threadGroup; /** - * Created in the {@link #start(int, boolean)} method. Terminated in {@link #join()} (FIX! Doing + * Created in the {@link #init(int, boolean)} method. Terminated in {@link #join()} (FIX! Doing * resource handling rather than observing in a #join is unexpected). * Overridden when we do the ProcedureTestingUtility.testRecoveryAndDoubleExecution trickery * (Should be ok). @@ -331,7 +334,7 @@ protected void periodicExecute(final TEnvironment env) { private CopyOnWriteArrayList workerThreads; /** - * Created in the {@link #start(int, boolean)} method. Terminated in {@link #join()} (FIX! Doing + * Created in the {@link #init(int, boolean)} method. Terminated in {@link #join()} (FIX! Doing * resource handling rather than observing in a #join is unexpected). * Overridden when we do the ProcedureTestingUtility.testRecoveryAndDoubleExecution trickery * (Should be ok). @@ -348,6 +351,9 @@ protected void periodicExecute(final TEnvironment env) { */ private final ProcedureScheduler scheduler; + private final Executor forceUpdateExecutor = Executors.newSingleThreadExecutor( + new ThreadFactoryBuilder().setDaemon(true).setNameFormat("Force-Update-PEWorker-%d").build()); + private final AtomicLong lastProcId = new AtomicLong(-1); private final AtomicLong workerId = new AtomicLong(0); private final AtomicInteger activeExecutorCount = new AtomicInteger(0); @@ -370,6 +376,32 @@ public ProcedureExecutor(final Configuration conf, final TEnvironment environmen this(conf, environment, store, new SimpleProcedureScheduler()); } + private boolean isRootFinished(Procedure proc) { + Procedure rootProc = procedures.get(proc.getRootProcId()); + return rootProc == null || rootProc.isFinished(); + } + + private void forceUpdateProcedure(long procId) throws IOException { + IdLock.Entry lockEntry = procExecutionLock.getLockEntry(procId); + try { + Procedure proc = procedures.get(procId); + if (proc == null) { + LOG.debug("No pending procedure with id = {}, skip force updating.", procId); + return; + } + // For a sub procedure which root parent has not been finished, we still need to retain the + // wal even if the procedure itself is finished. + if (proc.isFinished() && (!proc.hasParent() || isRootFinished(proc))) { + LOG.debug("Procedure {} has already been finished, skip force updating.", proc); + return; + } + LOG.debug("Force update procedure {}", proc); + store.update(proc); + } finally { + procExecutionLock.releaseLockEntry(lockEntry); + } + } + public ProcedureExecutor(final Configuration conf, final TEnvironment environment, final ProcedureStore store, final ProcedureScheduler scheduler) { this.environment = environment; @@ -378,7 +410,19 @@ public ProcedureExecutor(final Configuration conf, final TEnvironment environmen this.conf = conf; this.checkOwnerSet = conf.getBoolean(CHECK_OWNER_SET_CONF_KEY, DEFAULT_CHECK_OWNER_SET); refreshConfiguration(conf); + store.registerListener(new ProcedureStoreListener() { + @Override + public void forceUpdate(long[] procIds) { + Arrays.stream(procIds).forEach(procId -> forceUpdateExecutor.execute(() -> { + try { + forceUpdateProcedure(procId); + } catch (IOException e) { + LOG.warn("Failed to force update procedure with pid={}", procId); + } + })); + } + }); } private void load(final boolean abortOnCorruption) throws IOException { @@ -461,8 +505,10 @@ private void restoreLocks() { private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruption) throws IOException { // 1. Build the rollback stack - int runnablesCount = 0; + int runnableCount = 0; int failedCount = 0; + int waitingCount = 0; + int waitingTimeoutCount = 0; while (procIter.hasNext()) { boolean finished = procIter.isNextFinished(); @SuppressWarnings("unchecked") @@ -482,11 +528,21 @@ private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruptio // add the procedure to the map proc.beforeReplay(getEnvironment()); procedures.put(proc.getProcId(), proc); - - if (proc.getState() == ProcedureState.RUNNABLE) { - runnablesCount++; - } else if (proc.getState() == ProcedureState.FAILED) { - failedCount++; + switch (proc.getState()) { + case RUNNABLE: + runnableCount++; + break; + case FAILED: + failedCount++; + break; + case WAITING: + waitingCount++; + break; + case WAITING_TIMEOUT: + waitingTimeoutCount++; + break; + default: + break; } } @@ -507,9 +563,10 @@ private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruptio // have been polled out already, so when loading we can not add the procedure to scheduler first // and then call acquireLock, since the procedure is still in the queue, and since we will // remove the queue from runQueue, then no one can poll it out, then there is a dead lock - List> runnableList = new ArrayList<>(runnablesCount); + List> runnableList = new ArrayList<>(runnableCount); List> failedList = new ArrayList<>(failedCount); - Set> waitingSet = null; + List> waitingList = new ArrayList<>(waitingCount); + List> waitingTimeoutList = new ArrayList<>(waitingTimeoutCount); procIter.reset(); while (procIter.hasNext()) { if (procIter.isNextFinished()) { @@ -524,15 +581,11 @@ private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruptio LOG.debug("Loading {}", proc); Long rootProcId = getRootProcedureId(proc); - if (rootProcId == null) { - // The 'proc' was ready to run but the root procedure was rolledback? - scheduler.addBack(proc); - continue; - } + // The orphan procedures will be passed to handleCorrupted, so add an assert here + assert rootProcId != null; if (proc.hasParent()) { Procedure parent = procedures.get(proc.getParentProcId()); - // corrupted procedures are handled later at step 3 if (parent != null && !proc.isFinished()) { parent.incChildrenLatch(); } @@ -547,26 +600,10 @@ private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruptio runnableList.add(proc); break; case WAITING: - if (!proc.hasChildren()) { - // Normally, WAITING procedures should be waken by its children. - // But, there is a case that, all the children are successful and before - // they can wake up their parent procedure, the master was killed. - // So, during recovering the procedures from ProcedureWal, its children - // are not loaded because of their SUCCESS state. - // So we need to continue to run this WAITING procedure. But before - // executing, we need to set its state to RUNNABLE, otherwise, a exception - // will throw: - // Preconditions.checkArgument(procedure.getState() == ProcedureState.RUNNABLE, - // "NOT RUNNABLE! " + procedure.toString()); - proc.setState(ProcedureState.RUNNABLE); - runnableList.add(proc); - } + waitingList.add(proc); break; case WAITING_TIMEOUT: - if (waitingSet == null) { - waitingSet = new HashSet<>(); - } - waitingSet.add(proc); + waitingTimeoutList.add(proc); break; case FAILED: failedList.add(proc); @@ -581,36 +618,31 @@ private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruptio } } - // 3. Validate the stacks - int corruptedCount = 0; - Iterator>> itStack = - rollbackStack.entrySet().iterator(); - while (itStack.hasNext()) { - Map.Entry> entry = itStack.next(); - RootProcedureState procStack = entry.getValue(); - if (procStack.isValid()) continue; - - for (Procedure proc : procStack.getSubproceduresStack()) { - LOG.error("Corrupted " + proc); - procedures.remove(proc.getProcId()); - runnableList.remove(proc); - if (waitingSet != null) waitingSet.remove(proc); - corruptedCount++; + // 3. Check the waiting procedures to see if some of them can be added to runnable. + waitingList.forEach(proc -> { + if (!proc.hasChildren()) { + // Normally, WAITING procedures should be waken by its children. + // But, there is a case that, all the children are successful and before + // they can wake up their parent procedure, the master was killed. + // So, during recovering the procedures from ProcedureWal, its children + // are not loaded because of their SUCCESS state. + // So we need to continue to run this WAITING procedure. But before + // executing, we need to set its state to RUNNABLE, otherwise, a exception + // will throw: + // Preconditions.checkArgument(procedure.getState() == ProcedureState.RUNNABLE, + // "NOT RUNNABLE! " + procedure.toString()); + proc.setState(ProcedureState.RUNNABLE); + runnableList.add(proc); + } else { + proc.afterReplay(getEnvironment()); } - itStack.remove(); - } - - if (abortOnCorruption && corruptedCount > 0) { - throw new IOException("found " + corruptedCount + " procedures on replay"); - } + }); // 4. Push the procedures to the timeout executor - if (waitingSet != null && !waitingSet.isEmpty()) { - for (Procedure proc: waitingSet) { - proc.afterReplay(getEnvironment()); - timeoutExecutor.add(proc); - } - } + waitingTimeoutList.forEach(proc -> { + proc.afterReplay(getEnvironment()); + timeoutExecutor.add(proc); + }); // 5. restore locks restoreLocks(); // 6. Push the procedure to the scheduler @@ -620,8 +652,30 @@ private void loadProcedures(ProcedureIterator procIter, boolean abortOnCorruptio if (!p.hasParent()) { sendProcedureLoadedNotification(p.getProcId()); } - scheduler.addBack(p); + // If the procedure holds the lock, put the procedure in front + // If its parent holds the lock, put the procedure in front + // TODO. Is that possible that its ancestor holds the lock? + // For now, the deepest procedure hierarchy is: + // ModifyTableProcedure -> ReopenTableProcedure -> + // MoveTableProcedure -> Unassign/AssignProcedure + // But ModifyTableProcedure and ReopenTableProcedure won't hold the lock + // So, check parent lock is enough(a tricky case is resovled by HBASE-21384). + // If some one change or add new procedures making 'grandpa' procedure + // holds the lock, but parent procedure don't hold the lock, there will + // be a problem here. We have to check one procedure's ancestors. + // And we need to change LockAndQueue.hasParentLock(Procedure proc) method + // to check all ancestors too. + if (p.isLockedWhenLoading() || (p.hasParent() && procedures + .get(p.getParentProcId()).isLockedWhenLoading())) { + scheduler.addFront(p, false); + } else { + // if it was not, it can wait. + scheduler.addBack(p, false); + } }); + // After all procedures put into the queue, signal the worker threads. + // Otherwise, there is a race condition. See HBASE-21364. + scheduler.signalAll(); } /** @@ -977,7 +1031,7 @@ public long submitProcedure(Procedure proc) { * Bypass a procedure. If the procedure is set to bypass, all the logic in * execute/rollback will be ignored and it will return success, whatever. * It is used to recover buggy stuck procedures, releasing the lock resources - * and letting other procedures to run. Bypassing one procedure (and its ancestors will + * and letting other procedures run. Bypassing one procedure (and its ancestors will * be bypassed automatically) may leave the cluster in a middle state, e.g. region * not assigned, or some hdfs files left behind. After getting rid of those stuck procedures, * the operators may have to do some clean up on hdfs or schedule some assign procedures @@ -996,7 +1050,7 @@ public long submitProcedure(Procedure proc) { *

* If the procedure is in WAITING state, will set it to RUNNABLE add it to run queue. * TODO: What about WAITING_TIMEOUT? - * @param id the procedure id + * @param pids the procedure id * @param lockWait time to wait lock * @param force if force set to true, we will bypass the procedure even if it is executing. * This is for procedures which can't break out during executing(due to bug, mostly) @@ -1004,26 +1058,39 @@ public long submitProcedure(Procedure proc) { * there. We need to restart the master after bypassing, and letting the problematic * procedure to execute wth bypass=true, so in that condition, the procedure can be * successfully bypassed. + * @param recursive We will do an expensive search for children of each pid. EXPENSIVE! * @return true if bypass success * @throws IOException IOException */ - public boolean bypassProcedure(long id, long lockWait, boolean force) throws IOException { - Procedure procedure = getProcedure(id); + public List bypassProcedure(List pids, long lockWait, boolean force, + boolean recursive) + throws IOException { + List result = new ArrayList(pids.size()); + for(long pid: pids) { + result.add(bypassProcedure(pid, lockWait, force, recursive)); + } + return result; + } + + boolean bypassProcedure(long pid, long lockWait, boolean override, boolean recursive) + throws IOException { + Preconditions.checkArgument(lockWait > 0, "lockWait should be positive"); + final Procedure procedure = getProcedure(pid); if (procedure == null) { - LOG.debug("Procedure with id={} does not exist, skipping bypass", id); + LOG.debug("Procedure pid={} does not exist, skipping bypass", pid); return false; } - LOG.debug("Begin bypass {} with lockWait={}, force={}", procedure, lockWait, force); - + LOG.debug("Begin bypass {} with lockWait={}, override={}, recursive={}", + procedure, lockWait, override, recursive); IdLock.Entry lockEntry = procExecutionLock.tryLockEntry(procedure.getProcId(), lockWait); - if (lockEntry == null && !force) { + if (lockEntry == null && !override) { LOG.debug("Waited {} ms, but {} is still running, skipping bypass with force={}", - lockWait, procedure, force); + lockWait, procedure, override); return false; } else if (lockEntry == null) { LOG.debug("Waited {} ms, but {} is still running, begin bypass with force={}", - lockWait, procedure, force); + lockWait, procedure, override); } try { // check whether the procedure is already finished @@ -1033,8 +1100,25 @@ public boolean bypassProcedure(long id, long lockWait, boolean force) throws IOE } if (procedure.hasChildren()) { - LOG.debug("{} has children, skipping bypass", procedure); - return false; + if (recursive) { + // EXPENSIVE. Checks each live procedure of which there could be many!!! + // Is there another way to get children of a procedure? + LOG.info("Recursive bypass on children of pid={}", procedure.getProcId()); + this.procedures.forEachValue(1 /*Single-threaded*/, + // Transformer + v -> v.getParentProcId() == procedure.getProcId()? v: null, + // Consumer + v -> { + try { + bypassProcedure(v.getProcId(), lockWait, override, recursive); + } catch (IOException e) { + LOG.warn("Recursive bypass of pid={}", v.getProcId(), e); + } + }); + } else { + LOG.debug("{} has children, skipping bypass", procedure); + return false; + } } // If the procedure has no parent or no child, we are safe to bypass it in whatever state @@ -1044,16 +1128,17 @@ public boolean bypassProcedure(long id, long lockWait, boolean force) throws IOE LOG.debug("Bypassing procedures in RUNNABLE, WAITING and WAITING_TIMEOUT states " + "(with no parent), {}", procedure); + // Question: how is the bypass done here? return false; } // Now, the procedure is not finished, and no one can execute it since we take the lock now // And we can be sure that its ancestor is not running too, since their child has not // finished yet - Procedure current = procedure; + Procedure current = procedure; while (current != null) { LOG.debug("Bypassing {}", current); - current.bypass(); + current.bypass(getEnvironment()); store.update(procedure); long parentID = current.getParentProcId(); current = getProcedure(parentID); @@ -1549,7 +1634,19 @@ private LockState executeRollback(long rootProcId, RootProcedureState 0) { Procedure proc = subprocStack.get(stackTail); - + // For the sub procedures which are successfully finished, we do not rollback them. + // Typically, if we want to rollback a procedure, we first need to rollback it, and then + // recursively rollback its ancestors. The state changes which are done by sub procedures + // should be handled by parent procedures when rolling back. For example, when rolling back a + // MergeTableProcedure, we will schedule new procedures to bring the offline regions online, + // instead of rolling back the original procedures which offlined the regions(in fact these + // procedures can not be rolled back...). + if (proc.isSuccess()) { + // Just do the cleanup work, without actually executing the rollback + subprocStack.remove(stackTail); + cleanupAfterRollbackOneStep(proc); + continue; + } LockState lockState = acquireLock(proc); if (lockState != LockState.LOCK_ACQUIRED) { // can't take a lock on the procedure, add the root-proc back on the @@ -1588,6 +1685,31 @@ private LockState executeRollback(long rootProcId, RootProcedureState proc) { + if (proc.removeStackIndex()) { + if (!proc.isSuccess()) { + proc.setState(ProcedureState.ROLLEDBACK); + } + + // update metrics on finishing the procedure (fail) + proc.updateMetricsOnFinish(getEnvironment(), proc.elapsedTime(), false); + + if (proc.hasParent()) { + store.delete(proc.getProcId()); + procedures.remove(proc.getProcId()); + } else { + final long[] childProcIds = rollbackStack.get(proc.getProcId()).getSubprocedureIds(); + if (childProcIds != null) { + store.delete(proc, childProcIds); + } else { + store.update(proc); + } + } + } else { + store.update(proc); + } + } + /** * Execute the rollback of the procedure step. * It updates the store with the new state (stack index) @@ -1616,26 +1738,7 @@ private LockState executeRollback(Procedure proc) { throw new RuntimeException(msg); } - if (proc.removeStackIndex()) { - proc.setState(ProcedureState.ROLLEDBACK); - - // update metrics on finishing the procedure (fail) - proc.updateMetricsOnFinish(getEnvironment(), proc.elapsedTime(), false); - - if (proc.hasParent()) { - store.delete(proc.getProcId()); - procedures.remove(proc.getProcId()); - } else { - final long[] childProcIds = rollbackStack.get(proc.getProcId()).getSubprocedureIds(); - if (childProcIds != null) { - store.delete(proc, childProcIds); - } else { - store.update(proc); - } - } - } else { - store.update(proc); - } + cleanupAfterRollbackOneStep(proc); return LockState.LOCK_ACQUIRED; } @@ -1691,6 +1794,7 @@ private void execProcedure(RootProcedureState procStack, Procedure[] subprocs = null; do { reExecute = false; + procedure.resetPersistence(); try { subprocs = procedure.doExecute(getEnvironment()); if (subprocs != null && subprocs.length == 0) { @@ -1759,7 +1863,9 @@ private void execProcedure(RootProcedureState procStack, // // Commit the transaction even if a suspend (state may have changed). Note this append // can take a bunch of time to complete. - updateStoreOnExec(procStack, procedure, subprocs); + if (procedure.needPersistence()) { + updateStoreOnExec(procStack, procedure, subprocs); + } // if the store is not running we are aborting if (!store.isRunning()) { @@ -1953,6 +2059,11 @@ RootProcedureState getProcStack(long rootProcId) { return rollbackStack.get(rootProcId); } + @VisibleForTesting + ProcedureScheduler getProcedureScheduler() { + return scheduler; + } + // ========================================================================== // Worker Thread // ========================================================================== @@ -1973,7 +2084,6 @@ protected WorkerThread(ThreadGroup group, String prefix) { public void sendStopSignal() { scheduler.signalAll(); } - @Override public void run() { long lastUpdate = EnvironmentEdgeManager.currentTime(); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureScheduler.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureScheduler.java index e7e1cdbe4076..9489f52f3fa0 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureScheduler.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureScheduler.java @@ -52,6 +52,13 @@ public interface ProcedureScheduler { */ void addFront(Procedure proc); + /** + * Inserts the specified element at the front of this queue. + * @param proc the Procedure to add + * @param notify whether need to notify worker + */ + void addFront(Procedure proc, boolean notify); + /** * Inserts all elements in the iterator at the front of this queue. */ @@ -63,6 +70,13 @@ public interface ProcedureScheduler { */ void addBack(Procedure proc); + /** + * Inserts the specified element at the end of this queue. + * @param proc the Procedure to add + * @param notify whether need to notify worker + */ + void addBack(Procedure proc, boolean notify); + /** * The procedure can't run at the moment. * add it back to the queue, giving priority to someone else. diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureUtil.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureUtil.java index 8c8746e84bb4..b7362200d0a2 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureUtil.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/ProcedureUtil.java @@ -21,6 +21,7 @@ import java.io.InputStream; import java.lang.reflect.Constructor; import java.lang.reflect.Modifier; +import java.util.concurrent.ThreadLocalRandom; import org.apache.hadoop.hbase.HConstants; import org.apache.yetus.audience.InterfaceAudience; import org.apache.hbase.thirdparty.com.google.common.base.Preconditions; @@ -271,7 +272,7 @@ public static Procedure convertToProcedure(ProcedureProtos.Procedure proto) } if (proto.getBypass()) { - proc.bypass(); + proc.bypass(null); } ProcedureStateSerializer serializer = null; @@ -343,6 +344,9 @@ public static long getBackoffTimeMs(int attempts) { if (attempts >= 30) { return maxBackoffTime; } - return Math.min((long) (1000 * Math.pow(2, attempts)), maxBackoffTime); + long backoffTimeMs = Math.min((long) (1000 * Math.pow(2, attempts)), maxBackoffTime); + // 1% possible jitter + long jitter = (long) (backoffTimeMs * ThreadLocalRandom.current().nextFloat() * 0.01f); + return backoffTimeMs + jitter; } } diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RemoteProcedureException.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RemoteProcedureException.java index 6f4795d9dc48..f2ad17fbdbd3 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RemoteProcedureException.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RemoteProcedureException.java @@ -74,6 +74,10 @@ public Exception unwrapRemoteException() { return new Exception(cause); } + // NOTE: Does not throw DoNotRetryIOE because it does not + // have access (DNRIOE is in the client module). Use + // MasterProcedureUtil.unwrapRemoteIOException if need to + // throw DNRIOE. public IOException unwrapRemoteIOException() { final Exception cause = unwrapRemoteException(); if (cause instanceof IOException) { diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RootProcedureState.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RootProcedureState.java index 2fc00301e915..a7cdaabb2489 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RootProcedureState.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/RootProcedureState.java @@ -24,6 +24,8 @@ import java.util.Set; import org.apache.yetus.audience.InterfaceAudience; import org.apache.yetus.audience.InterfaceStability; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; @@ -42,6 +44,8 @@ @InterfaceStability.Evolving class RootProcedureState { + private static final Logger LOG = LoggerFactory.getLogger(RootProcedureState.class); + private enum State { RUNNING, // The Procedure is running or ready to run FAILED, // The Procedure failed, waiting for the rollback executing @@ -146,6 +150,7 @@ protected synchronized void addRollbackStep(Procedure proc) { subprocStack = new ArrayList<>(); } proc.addStackIndex(subprocStack.size()); + LOG.debug("Add procedure {} as the {}th rollback step", proc, subprocStack.size()); subprocStack.add(proc); } diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/StateMachineProcedure.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/StateMachineProcedure.java index 986b250d9bda..0a087a6a0dd0 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/StateMachineProcedure.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/StateMachineProcedure.java @@ -219,12 +219,16 @@ protected boolean isEofState() { @Override protected boolean abort(final TEnvironment env) { LOG.debug("Abort requested for {}", this); - if (hasMoreState()) { - aborted.set(true); - return true; + if (!hasMoreState()) { + LOG.warn("Ignore abort request on {} because it has already been finished", this); + return false; } - LOG.debug("Ignoring abort request on {}", this); - return false; + if (!isRollbackSupported(getCurrentState())) { + LOG.warn("Ignore abort request on {} because it does not support rollback", this); + return false; + } + aborted.set(true); + return true; } /** diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/BitSetNode.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/BitSetNode.java new file mode 100644 index 000000000000..3102bde7d193 --- /dev/null +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/BitSetNode.java @@ -0,0 +1,423 @@ +/** + * 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.procedure2.store; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker.DeleteState; +import org.apache.yetus.audience.InterfaceAudience; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; + +/** + * A bitmap which can grow/merge with other {@link BitSetNode} (if certain conditions are met). + * Boundaries of bitmap are aligned to multiples of {@link BitSetNode#BITS_PER_WORD}. So the range + * of a {@link BitSetNode} is from [x * K, y * K) where x and y are integers, y > x and K is + * BITS_PER_WORD. + *

+ * We have two main bit sets to describe the state of procedures, the meanings are: + * + * 

+ *  ----------------------
+ * | modified | deleted |  meaning
+ * |     0    |   0     |  proc exists, but hasn't been updated since last resetUpdates().
+ * |     1    |   0     |  proc was updated (but not deleted).
+ * |     1    |   1     |  proc was deleted.
+ * |     0    |   1     |  proc doesn't exist (maybe never created, maybe deleted in past).
+ * ----------------------
+ *
+ * + * The meaning of modified is that, we have modified the state of the procedure, no matter insert, + * update, or delete. And if it is an insert or update, we will set the deleted to 0, if not we will + * set the delete to 1. + *

+ * For a non-partial BitSetNode, the initial modified value is 0 and deleted value is 1. For the + * partial one, the initial modified value is 0 and the initial deleted value is also 0. In + * {@link #unsetPartialFlag()} we will reset the deleted to 1 if it is not modified. + */ +@InterfaceAudience.Private +class BitSetNode { + private static final long WORD_MASK = 0xffffffffffffffffL; + private static final int ADDRESS_BITS_PER_WORD = 6; + private static final int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD; + private static final int MAX_NODE_SIZE = 1 << ADDRESS_BITS_PER_WORD; + + /** + * Mimics {@link ProcedureStoreTracker#partial}. It will effect how we fill the new deleted bits + * when growing. + */ + private boolean partial; + + /** + * Set of procedures which have been modified since last {@link #resetModified()}. Useful to track + * procedures which have been modified since last WAL write. + */ + private long[] modified; + + /** + * Keeps track of procedure ids which belong to this bitmap's range and have been deleted. This + * represents global state since it's not reset on WAL rolls. + */ + private long[] deleted; + /** + * Offset of bitmap i.e. procedure id corresponding to first bit. + */ + private long start; + + public void dump() { + System.out.printf("%06d:%06d min=%d max=%d%n", getStart(), getEnd(), getActiveMinProcId(), + getActiveMaxProcId()); + System.out.println("Modified:"); + for (int i = 0; i < modified.length; ++i) { + for (int j = 0; j < BITS_PER_WORD; ++j) { + System.out.print((modified[i] & (1L << j)) != 0 ? "1" : "0"); + } + System.out.println(" " + i); + } + System.out.println(); + System.out.println("Delete:"); + for (int i = 0; i < deleted.length; ++i) { + for (int j = 0; j < BITS_PER_WORD; ++j) { + System.out.print((deleted[i] & (1L << j)) != 0 ? "1" : "0"); + } + System.out.println(" " + i); + } + System.out.println(); + } + + public BitSetNode(long procId, boolean partial) { + start = alignDown(procId); + + int count = 1; + modified = new long[count]; + deleted = new long[count]; + if (!partial) { + Arrays.fill(deleted, WORD_MASK); + } + + this.partial = partial; + updateState(procId, false); + } + + public BitSetNode(ProcedureProtos.ProcedureStoreTracker.TrackerNode data) { + start = data.getStartId(); + int size = data.getUpdatedCount(); + assert size == data.getDeletedCount(); + modified = new long[size]; + deleted = new long[size]; + for (int i = 0; i < size; ++i) { + modified[i] = data.getUpdated(i); + deleted[i] = data.getDeleted(i); + } + partial = false; + } + + public BitSetNode(BitSetNode other, boolean resetDelete) { + this.start = other.start; + // The resetDelete will be set to true when building cleanup tracker. + // as we will reset deleted flags for all the unmodified bits to 1, the partial flag is useless + // so set it to false for not confusing the developers when debugging. + this.partial = resetDelete ? false : other.partial; + this.modified = other.modified.clone(); + // The intention here is that, if a procedure is not modified in this tracker, then we do not + // need to take care of it, so we will set deleted to true for these bits, i.e, if modified is + // 0, then we set deleted to 1, otherwise keep it as is. So here, the equation is + // deleted |= ~modified, i.e, + if (resetDelete) { + this.deleted = new long[other.deleted.length]; + for (int i = 0; i < this.deleted.length; ++i) { + this.deleted[i] |= ~(other.modified[i]); + } + } else { + this.deleted = other.deleted.clone(); + } + } + + public void insertOrUpdate(final long procId) { + updateState(procId, false); + } + + public void delete(final long procId) { + updateState(procId, true); + } + + public long getStart() { + return start; + } + + public long getEnd() { + return start + (modified.length << ADDRESS_BITS_PER_WORD) - 1; + } + + public boolean contains(final long procId) { + return start <= procId && procId <= getEnd(); + } + + public DeleteState isDeleted(final long procId) { + int bitmapIndex = getBitmapIndex(procId); + int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; + if (wordIndex >= deleted.length) { + return DeleteState.MAYBE; + } + return (deleted[wordIndex] & (1L << bitmapIndex)) != 0 ? DeleteState.YES : DeleteState.NO; + } + + public boolean isModified(long procId) { + int bitmapIndex = getBitmapIndex(procId); + int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; + if (wordIndex >= modified.length) { + return false; + } + return (modified[wordIndex] & (1L << bitmapIndex)) != 0; + } + + /** + * @return true, if all the procedures has been modified. + */ + public boolean isAllModified() { + // TODO: cache the value + for (int i = 0; i < modified.length; ++i) { + if ((modified[i] | deleted[i]) != WORD_MASK) { + return false; + } + } + return true; + } + + /** + * @return all the active procedure ids in this bit set. + */ + public long[] getActiveProcIds() { + List procIds = new ArrayList<>(); + for (int wordIndex = 0; wordIndex < modified.length; wordIndex++) { + if (deleted[wordIndex] == WORD_MASK || modified[wordIndex] == 0) { + // This should be the common case, where most procedures has been deleted. + continue; + } + long baseProcId = getStart() + (wordIndex << ADDRESS_BITS_PER_WORD); + for (int i = 0; i < (1 << ADDRESS_BITS_PER_WORD); i++) { + long mask = 1L << i; + if ((deleted[wordIndex] & mask) == 0 && (modified[wordIndex] & mask) != 0) { + procIds.add(baseProcId + i); + } + } + } + return procIds.stream().mapToLong(Long::longValue).toArray(); + } + + /** + * @return true, if there are no active procedures in this BitSetNode, else false. + */ + public boolean isEmpty() { + // TODO: cache the value + for (int i = 0; i < deleted.length; ++i) { + if (deleted[i] != WORD_MASK) { + return false; + } + } + return true; + } + + public void resetModified() { + Arrays.fill(modified, 0); + } + + public void unsetPartialFlag() { + partial = false; + for (int i = 0; i < modified.length; ++i) { + for (int j = 0; j < BITS_PER_WORD; ++j) { + if ((modified[i] & (1L << j)) == 0) { + deleted[i] |= (1L << j); + } + } + } + } + + /** + * Convert to + * org.apache.hadoop.hbase.protobuf.generated.ProcedureProtos.ProcedureStoreTracker.TrackerNode + * protobuf. + */ + public ProcedureProtos.ProcedureStoreTracker.TrackerNode convert() { + ProcedureProtos.ProcedureStoreTracker.TrackerNode.Builder builder = + ProcedureProtos.ProcedureStoreTracker.TrackerNode.newBuilder(); + builder.setStartId(start); + for (int i = 0; i < modified.length; ++i) { + builder.addUpdated(modified[i]); + builder.addDeleted(deleted[i]); + } + return builder.build(); + } + + // ======================================================================== + // Grow/Merge Helpers + // ======================================================================== + public boolean canGrow(final long procId) { + return Math.abs(procId - start) < MAX_NODE_SIZE; + } + + public boolean canMerge(final BitSetNode rightNode) { + // Can just compare 'starts' since boundaries are aligned to multiples of BITS_PER_WORD. + assert start < rightNode.start; + return (rightNode.getEnd() - start) < MAX_NODE_SIZE; + } + + public void grow(final long procId) { + int delta, offset; + + if (procId < start) { + // add to head + long newStart = alignDown(procId); + delta = (int) (start - newStart) >> ADDRESS_BITS_PER_WORD; + offset = delta; + start = newStart; + } else { + // Add to tail + long newEnd = alignUp(procId + 1); + delta = (int) (newEnd - getEnd()) >> ADDRESS_BITS_PER_WORD; + offset = 0; + } + + long[] newBitmap; + int oldSize = modified.length; + + newBitmap = new long[oldSize + delta]; + for (int i = 0; i < newBitmap.length; ++i) { + newBitmap[i] = 0; + } + System.arraycopy(modified, 0, newBitmap, offset, oldSize); + modified = newBitmap; + + newBitmap = new long[deleted.length + delta]; + for (int i = 0; i < newBitmap.length; ++i) { + newBitmap[i] = partial ? 0 : WORD_MASK; + } + System.arraycopy(deleted, 0, newBitmap, offset, oldSize); + deleted = newBitmap; + } + + public void merge(final BitSetNode rightNode) { + int delta = (int) (rightNode.getEnd() - getEnd()) >> ADDRESS_BITS_PER_WORD; + + long[] newBitmap; + int oldSize = modified.length; + int newSize = (delta - rightNode.modified.length); + int offset = oldSize + newSize; + + newBitmap = new long[oldSize + delta]; + System.arraycopy(modified, 0, newBitmap, 0, oldSize); + System.arraycopy(rightNode.modified, 0, newBitmap, offset, rightNode.modified.length); + modified = newBitmap; + + newBitmap = new long[oldSize + delta]; + System.arraycopy(deleted, 0, newBitmap, 0, oldSize); + System.arraycopy(rightNode.deleted, 0, newBitmap, offset, rightNode.deleted.length); + deleted = newBitmap; + + for (int i = 0; i < newSize; ++i) { + modified[offset + i] = 0; + deleted[offset + i] = partial ? 0 : WORD_MASK; + } + } + + @Override + public String toString() { + return "BitSetNode(" + getStart() + "-" + getEnd() + ")"; + } + + // ======================================================================== + // Min/Max Helpers + // ======================================================================== + public long getActiveMinProcId() { + long minProcId = start; + for (int i = 0; i < deleted.length; ++i) { + if (deleted[i] == 0) { + return minProcId; + } + + if (deleted[i] != WORD_MASK) { + for (int j = 0; j < BITS_PER_WORD; ++j) { + if ((deleted[i] & (1L << j)) == 0) { + return minProcId + j; + } + } + } + + minProcId += BITS_PER_WORD; + } + return Procedure.NO_PROC_ID; + } + + public long getActiveMaxProcId() { + long maxProcId = getEnd(); + for (int i = deleted.length - 1; i >= 0; --i) { + if (deleted[i] == 0) { + return maxProcId; + } + + if (deleted[i] != WORD_MASK) { + for (int j = BITS_PER_WORD - 1; j >= 0; --j) { + if ((deleted[i] & (1L << j)) == 0) { + return maxProcId - (BITS_PER_WORD - 1 - j); + } + } + } + maxProcId -= BITS_PER_WORD; + } + return Procedure.NO_PROC_ID; + } + + // ======================================================================== + // Bitmap Helpers + // ======================================================================== + private int getBitmapIndex(final long procId) { + return (int) (procId - start); + } + + void updateState(long procId, boolean isDeleted) { + int bitmapIndex = getBitmapIndex(procId); + int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; + long value = (1L << bitmapIndex); + + modified[wordIndex] |= value; + if (isDeleted) { + deleted[wordIndex] |= value; + } else { + deleted[wordIndex] &= ~value; + } + } + + // ======================================================================== + // Helpers + // ======================================================================== + /** + * @return upper boundary (aligned to multiple of BITS_PER_WORD) of bitmap range x belongs to. + */ + private static long alignUp(final long x) { + return (x + (BITS_PER_WORD - 1)) & -BITS_PER_WORD; + } + + /** + * @return lower boundary (aligned to multiple of BITS_PER_WORD) of bitmap range x belongs to. + */ + private static long alignDown(final long x) { + return x & -BITS_PER_WORD; + } +} \ No newline at end of file diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/NoopProcedureStore.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/NoopProcedureStore.java index 9c6176d4bb88..8fbc1473ed7e 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/NoopProcedureStore.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/NoopProcedureStore.java @@ -15,7 +15,6 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2.store; import java.io.IOException; @@ -64,17 +63,17 @@ public void load(final ProcedureLoader loader) throws IOException { } @Override - public void insert(Procedure proc, Procedure[] subprocs) { + public void insert(Procedure proc, Procedure[] subprocs) { // no-op } @Override - public void insert(Procedure[] proc) { + public void insert(Procedure[] proc) { // no-op } @Override - public void update(Procedure proc) { + public void update(Procedure proc) { // no-op } @@ -84,7 +83,7 @@ public void delete(long procId) { } @Override - public void delete(Procedure proc, long[] subprocs) { + public void delete(Procedure proc, long[] subprocs) { // no-op } diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStore.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStore.java index 72883405d7c1..7a77a20171c8 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStore.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStore.java @@ -34,19 +34,37 @@ public interface ProcedureStore { /** * Store listener interface. + *

* The main process should register a listener and respond to the store events. */ public interface ProcedureStoreListener { + /** * triggered when the store sync is completed. */ - void postSync(); + default void postSync() { + } + + /** + * triggered when the store is not able to write out data. the main process should abort. + */ + default void abortProcess() { + } /** - * triggered when the store is not able to write out data. - * the main process should abort. + * Suggest that the upper layer should update the state of some procedures. Ignore this call + * will not effect correctness but performance. + *

+ * For a WAL based ProcedureStore implementation, if all the procedures stored in a WAL file + * have been deleted, or updated later in another WAL file, then we can delete the WAL file. If + * there are old procedures in a WAL file which are never deleted or updated, then we can not + * delete the WAL file and this will cause we hold lots of WAL file and slow down the master + * restarts. So here we introduce this method to tell the upper layer that please update the + * states of these procedures so that we can delete the old WAL file. + * @param procIds the id for the procedures */ - void abortProcess(); + default void forceUpdate(long[] procIds) { + } } /** @@ -67,12 +85,18 @@ public interface ProcedureIterator { boolean hasNext(); /** + * Calling this method does not need to convert the protobuf message to the Procedure class, so + * if it returns true we can call {@link #skipNext()} to skip the procedure without + * deserializing. This could increase the performance. * @return true if the iterator next element is a completed procedure. */ boolean isNextFinished(); /** * Skip the next procedure + *

+ * This method is used to skip the deserializing of the procedure to increase performance, as + * when calling next we need to convert the protobuf message to the Procedure class. */ void skipNext(); @@ -81,6 +105,7 @@ public interface ProcedureIterator { * @throws IOException if there was an error fetching/deserializing the procedure * @return the next procedure in the iteration. */ + @SuppressWarnings("rawtypes") Procedure next() throws IOException; } @@ -173,7 +198,7 @@ public interface ProcedureLoader { * @param proc the procedure to serialize and write to the store. * @param subprocs the newly created child of the proc. */ - void insert(Procedure proc, Procedure[] subprocs); + void insert(Procedure proc, Procedure[] subprocs); /** * Serialize a set of new procedures. @@ -182,14 +207,14 @@ public interface ProcedureLoader { * * @param procs the procedures to serialize and write to the store. */ - void insert(Procedure[] procs); + void insert(Procedure[] procs); /** * The specified procedure was executed, * and the new state should be written to the store. * @param proc the procedure to serialize and write to the store. */ - void update(Procedure proc); + void update(Procedure proc); /** * The specified procId was removed from the executor, @@ -205,7 +230,7 @@ public interface ProcedureLoader { * @param parentProc the parent procedure to serialize and write to the store. * @param subProcIds the IDs of the sub-procedure to remove. */ - void delete(Procedure parentProc, long[] subProcIds); + void delete(Procedure parentProc, long[] subProcIds); /** * The specified procIds were removed from the executor, diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreBase.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreBase.java index 90da9331f046..b1a8d3d1a2e0 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreBase.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreBase.java @@ -15,12 +15,10 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2.store; import java.util.concurrent.CopyOnWriteArrayList; import java.util.concurrent.atomic.AtomicBoolean; - import org.apache.yetus.audience.InterfaceAudience; /** @@ -58,19 +56,15 @@ public boolean unregisterListener(ProcedureStoreListener listener) { return listeners.remove(listener); } - protected void sendPostSyncSignal() { - if (!this.listeners.isEmpty()) { - for (ProcedureStoreListener listener : this.listeners) { - listener.postSync(); - } - } + protected final void sendPostSyncSignal() { + listeners.forEach(ProcedureStoreListener::postSync); + } + + protected final void sendAbortProcessSignal() { + listeners.forEach(ProcedureStoreListener::abortProcess); } - protected void sendAbortProcessSignal() { - if (!this.listeners.isEmpty()) { - for (ProcedureStoreListener listener : this.listeners) { - listener.abortProcess(); - } - } + protected final void sendForceUpdateSignal(long[] procIds) { + listeners.forEach(l -> l.forceUpdate(procIds)); } } diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreTracker.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreTracker.java index 2dad5ac72ce0..25c94272f088 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreTracker.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/ProcedureStoreTracker.java @@ -23,9 +23,13 @@ import java.util.Iterator; import java.util.Map; import java.util.TreeMap; - +import java.util.function.BiFunction; +import java.util.stream.LongStream; +import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; /** @@ -35,8 +39,10 @@ * deleted/completed to avoid the deserialization step on restart */ @InterfaceAudience.Private -@InterfaceStability.Evolving public class ProcedureStoreTracker { + + private static final Logger LOG = LoggerFactory.getLogger(ProcedureStoreTracker.class); + // Key is procedure id corresponding to first bit of the bitmap. private final TreeMap map = new TreeMap<>(); @@ -53,383 +59,14 @@ public class ProcedureStoreTracker { * It's set to true only when recovering from old logs. See {@link #isDeleted(long)} docs to * understand it's real use. */ - private boolean partial = false; + boolean partial = false; - private long minUpdatedProcId = Long.MAX_VALUE; - private long maxUpdatedProcId = Long.MIN_VALUE; + private long minModifiedProcId = Long.MAX_VALUE; + private long maxModifiedProcId = Long.MIN_VALUE; public enum DeleteState { YES, NO, MAYBE } - /** - * A bitmap which can grow/merge with other {@link BitSetNode} (if certain conditions are met). - * Boundaries of bitmap are aligned to multiples of {@link BitSetNode#BITS_PER_WORD}. So the - * range of a {@link BitSetNode} is from [x * K, y * K) where x and y are integers, y > x and K - * is BITS_PER_WORD. - */ - public static class BitSetNode { - private final static long WORD_MASK = 0xffffffffffffffffL; - private final static int ADDRESS_BITS_PER_WORD = 6; - private final static int BITS_PER_WORD = 1 << ADDRESS_BITS_PER_WORD; - private final static int MAX_NODE_SIZE = 1 << ADDRESS_BITS_PER_WORD; - - /** - * Mimics {@link ProcedureStoreTracker#partial}. - */ - private final boolean partial; - - /* ---------------------- - * | updated | deleted | meaning - * | 0 | 0 | proc exists, but hasn't been updated since last resetUpdates(). - * | 1 | 0 | proc was updated (but not deleted). - * | 1 | 1 | proc was deleted. - * | 0 | 1 | proc doesn't exist (maybe never created, maybe deleted in past). - /* ---------------------- - */ - - /** - * Set of procedures which have been updated since last {@link #resetUpdates()}. - * Useful to track procedures which have been updated since last WAL write. - */ - private long[] updated; - /** - * Keeps track of procedure ids which belong to this bitmap's range and have been deleted. - * This represents global state since it's not reset on WAL rolls. - */ - private long[] deleted; - /** - * Offset of bitmap i.e. procedure id corresponding to first bit. - */ - private long start; - - public void dump() { - System.out.printf("%06d:%06d min=%d max=%d%n", getStart(), getEnd(), - getActiveMinProcId(), getActiveMaxProcId()); - System.out.println("Update:"); - for (int i = 0; i < updated.length; ++i) { - for (int j = 0; j < BITS_PER_WORD; ++j) { - System.out.print((updated[i] & (1L << j)) != 0 ? "1" : "0"); - } - System.out.println(" " + i); - } - System.out.println(); - System.out.println("Delete:"); - for (int i = 0; i < deleted.length; ++i) { - for (int j = 0; j < BITS_PER_WORD; ++j) { - System.out.print((deleted[i] & (1L << j)) != 0 ? "1" : "0"); - } - System.out.println(" " + i); - } - System.out.println(); - } - - public BitSetNode(final long procId, final boolean partial) { - start = alignDown(procId); - - int count = 1; - updated = new long[count]; - deleted = new long[count]; - for (int i = 0; i < count; ++i) { - updated[i] = 0; - deleted[i] = partial ? 0 : WORD_MASK; - } - - this.partial = partial; - updateState(procId, false); - } - - protected BitSetNode(final long start, final long[] updated, final long[] deleted) { - this.start = start; - this.updated = updated; - this.deleted = deleted; - this.partial = false; - } - - public BitSetNode(ProcedureProtos.ProcedureStoreTracker.TrackerNode data) { - start = data.getStartId(); - int size = data.getUpdatedCount(); - updated = new long[size]; - deleted = new long[size]; - for (int i = 0; i < size; ++i) { - updated[i] = data.getUpdated(i); - deleted[i] = data.getDeleted(i); - } - partial = false; - } - - public BitSetNode(final BitSetNode other, final boolean resetDelete) { - this.start = other.start; - this.partial = other.partial; - this.updated = other.updated.clone(); - if (resetDelete) { - this.deleted = new long[other.deleted.length]; - for (int i = 0; i < this.deleted.length; ++i) { - this.deleted[i] = ~(other.updated[i]); - } - } else { - this.deleted = other.deleted.clone(); - } - } - - public void update(final long procId) { - updateState(procId, false); - } - - public void delete(final long procId) { - updateState(procId, true); - } - - public long getStart() { - return start; - } - - public long getEnd() { - return start + (updated.length << ADDRESS_BITS_PER_WORD) - 1; - } - - public boolean contains(final long procId) { - return start <= procId && procId <= getEnd(); - } - - public DeleteState isDeleted(final long procId) { - int bitmapIndex = getBitmapIndex(procId); - int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; - if (wordIndex >= deleted.length) { - return DeleteState.MAYBE; - } - return (deleted[wordIndex] & (1L << bitmapIndex)) != 0 ? DeleteState.YES : DeleteState.NO; - } - - private boolean isUpdated(final long procId) { - int bitmapIndex = getBitmapIndex(procId); - int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; - if (wordIndex >= updated.length) { - return false; - } - return (updated[wordIndex] & (1L << bitmapIndex)) != 0; - } - - public boolean isUpdated() { - // TODO: cache the value - for (int i = 0; i < updated.length; ++i) { - if ((updated[i] | deleted[i]) != WORD_MASK) { - return false; - } - } - return true; - } - - /** - * @return true, if there are no active procedures in this BitSetNode, else false. - */ - public boolean isEmpty() { - // TODO: cache the value - for (int i = 0; i < deleted.length; ++i) { - if (deleted[i] != WORD_MASK) { - return false; - } - } - return true; - } - - public void resetUpdates() { - for (int i = 0; i < updated.length; ++i) { - updated[i] = 0; - } - } - - /** - * Clears the {@link #deleted} bitmaps. - */ - public void undeleteAll() { - for (int i = 0; i < updated.length; ++i) { - deleted[i] = 0; - } - } - - public void unsetPartialFlag() { - for (int i = 0; i < updated.length; ++i) { - for (int j = 0; j < BITS_PER_WORD; ++j) { - if ((updated[i] & (1L << j)) == 0) { - deleted[i] |= (1L << j); - } - } - } - } - - /** - * Convert to - * org.apache.hadoop.hbase.protobuf.generated.ProcedureProtos.ProcedureStoreTracker.TrackerNode - * protobuf. - */ - public ProcedureProtos.ProcedureStoreTracker.TrackerNode convert() { - ProcedureProtos.ProcedureStoreTracker.TrackerNode.Builder builder = - ProcedureProtos.ProcedureStoreTracker.TrackerNode.newBuilder(); - builder.setStartId(start); - for (int i = 0; i < updated.length; ++i) { - builder.addUpdated(updated[i]); - builder.addDeleted(deleted[i]); - } - return builder.build(); - } - - // ======================================================================== - // Grow/Merge Helpers - // ======================================================================== - public boolean canGrow(final long procId) { - return Math.abs(procId - start) < MAX_NODE_SIZE; - } - - public boolean canMerge(final BitSetNode rightNode) { - // Can just compare 'starts' since boundaries are aligned to multiples of BITS_PER_WORD. - assert start < rightNode.start; - return (rightNode.getEnd() - start) < MAX_NODE_SIZE; - } - - public void grow(final long procId) { - int delta, offset; - - if (procId < start) { - // add to head - long newStart = alignDown(procId); - delta = (int)(start - newStart) >> ADDRESS_BITS_PER_WORD; - offset = delta; - start = newStart; - } else { - // Add to tail - long newEnd = alignUp(procId + 1); - delta = (int)(newEnd - getEnd()) >> ADDRESS_BITS_PER_WORD; - offset = 0; - } - - long[] newBitmap; - int oldSize = updated.length; - - newBitmap = new long[oldSize + delta]; - for (int i = 0; i < newBitmap.length; ++i) { - newBitmap[i] = 0; - } - System.arraycopy(updated, 0, newBitmap, offset, oldSize); - updated = newBitmap; - - newBitmap = new long[deleted.length + delta]; - for (int i = 0; i < newBitmap.length; ++i) { - newBitmap[i] = partial ? 0 : WORD_MASK; - } - System.arraycopy(deleted, 0, newBitmap, offset, oldSize); - deleted = newBitmap; - } - - public void merge(final BitSetNode rightNode) { - int delta = (int)(rightNode.getEnd() - getEnd()) >> ADDRESS_BITS_PER_WORD; - - long[] newBitmap; - int oldSize = updated.length; - int newSize = (delta - rightNode.updated.length); - int offset = oldSize + newSize; - - newBitmap = new long[oldSize + delta]; - System.arraycopy(updated, 0, newBitmap, 0, oldSize); - System.arraycopy(rightNode.updated, 0, newBitmap, offset, rightNode.updated.length); - updated = newBitmap; - - newBitmap = new long[oldSize + delta]; - System.arraycopy(deleted, 0, newBitmap, 0, oldSize); - System.arraycopy(rightNode.deleted, 0, newBitmap, offset, rightNode.deleted.length); - deleted = newBitmap; - - for (int i = 0; i < newSize; ++i) { - updated[offset + i] = 0; - deleted[offset + i] = partial ? 0 : WORD_MASK; - } - } - - @Override - public String toString() { - return "BitSetNode(" + getStart() + "-" + getEnd() + ")"; - } - - // ======================================================================== - // Min/Max Helpers - // ======================================================================== - public long getActiveMinProcId() { - long minProcId = start; - for (int i = 0; i < deleted.length; ++i) { - if (deleted[i] == 0) { - return(minProcId); - } - - if (deleted[i] != WORD_MASK) { - for (int j = 0; j < BITS_PER_WORD; ++j) { - if ((deleted[i] & (1L << j)) != 0) { - return minProcId + j; - } - } - } - - minProcId += BITS_PER_WORD; - } - return minProcId; - } - - public long getActiveMaxProcId() { - long maxProcId = getEnd(); - for (int i = deleted.length - 1; i >= 0; --i) { - if (deleted[i] == 0) { - return maxProcId; - } - - if (deleted[i] != WORD_MASK) { - for (int j = BITS_PER_WORD - 1; j >= 0; --j) { - if ((deleted[i] & (1L << j)) == 0) { - return maxProcId - (BITS_PER_WORD - 1 - j); - } - } - } - maxProcId -= BITS_PER_WORD; - } - return maxProcId; - } - - // ======================================================================== - // Bitmap Helpers - // ======================================================================== - private int getBitmapIndex(final long procId) { - return (int)(procId - start); - } - - private void updateState(final long procId, final boolean isDeleted) { - int bitmapIndex = getBitmapIndex(procId); - int wordIndex = bitmapIndex >> ADDRESS_BITS_PER_WORD; - long value = (1L << bitmapIndex); - - updated[wordIndex] |= value; - if (isDeleted) { - deleted[wordIndex] |= value; - } else { - deleted[wordIndex] &= ~value; - } - } - - - // ======================================================================== - // Helpers - // ======================================================================== - /** - * @return upper boundary (aligned to multiple of BITS_PER_WORD) of bitmap range x belongs to. - */ - private static long alignUp(final long x) { - return (x + (BITS_PER_WORD - 1)) & -BITS_PER_WORD; - } - - /** - * @return lower boundary (aligned to multiple of BITS_PER_WORD) of bitmap range x belongs to. - */ - private static long alignDown(final long x) { - return x & -BITS_PER_WORD; - } - } - - public void resetToProto(final ProcedureProtos.ProcedureStoreTracker trackerProtoBuf) { + public void resetToProto(ProcedureProtos.ProcedureStoreTracker trackerProtoBuf) { reset(); for (ProcedureProtos.ProcedureStoreTracker.TrackerNode protoNode: trackerProtoBuf.getNodeList()) { final BitSetNode node = new BitSetNode(protoNode); @@ -440,14 +77,26 @@ public void resetToProto(final ProcedureProtos.ProcedureStoreTracker trackerProt /** * Resets internal state to same as given {@code tracker}. Does deep copy of the bitmap. */ - public void resetTo(final ProcedureStoreTracker tracker) { + public void resetTo(ProcedureStoreTracker tracker) { resetTo(tracker, false); } - public void resetTo(final ProcedureStoreTracker tracker, final boolean resetDelete) { - this.partial = tracker.partial; - this.minUpdatedProcId = tracker.minUpdatedProcId; - this.maxUpdatedProcId = tracker.maxUpdatedProcId; + /** + * Resets internal state to same as given {@code tracker}, and change the deleted flag according + * to the modified flag if {@code resetDelete} is true. Does deep copy of the bitmap. + *

+ * The {@code resetDelete} will be set to true when building cleanup tracker, please see the + * comments in {@link BitSetNode#BitSetNode(BitSetNode, boolean)} to learn how we change the + * deleted flag if {@code resetDelete} is true. + */ + public void resetTo(ProcedureStoreTracker tracker, boolean resetDelete) { + reset(); + // resetDelete will true if we are building the cleanup tracker, as we will reset deleted flags + // for all the unmodified bits to 1, the partial flag is useless so set it to false for not + // confusing the developers when debugging. + this.partial = resetDelete ? false : tracker.partial; + this.minModifiedProcId = tracker.minModifiedProcId; + this.maxModifiedProcId = tracker.maxModifiedProcId; this.keepDeletes = tracker.keepDeletes; for (Map.Entry entry : tracker.map.entrySet()) { map.put(entry.getKey(), new BitSetNode(entry.getValue(), resetDelete)); @@ -458,25 +107,24 @@ public void insert(long procId) { insert(null, procId); } - public void insert(final long[] procIds) { + public void insert(long[] procIds) { for (int i = 0; i < procIds.length; ++i) { insert(procIds[i]); } } - public void insert(final long procId, final long[] subProcIds) { - BitSetNode node = null; - node = update(node, procId); + public void insert(long procId, long[] subProcIds) { + BitSetNode node = update(null, procId); for (int i = 0; i < subProcIds.length; ++i) { node = insert(node, subProcIds[i]); } } - private BitSetNode insert(BitSetNode node, final long procId) { + private BitSetNode insert(BitSetNode node, long procId) { if (node == null || !node.contains(procId)) { node = getOrCreateNode(procId); } - node.update(procId); + node.insertOrUpdate(procId); trackProcIds(procId); return node; } @@ -485,11 +133,11 @@ public void update(long procId) { update(null, procId); } - private BitSetNode update(BitSetNode node, final long procId) { + private BitSetNode update(BitSetNode node, long procId) { node = lookupClosestNode(node, procId); assert node != null : "expected node to update procId=" + procId; assert node.contains(procId) : "expected procId=" + procId + " in the node"; - node.update(procId); + node.insertOrUpdate(procId); trackProcIds(procId); return node; } @@ -506,10 +154,12 @@ public void delete(final long[] procIds) { } } - private BitSetNode delete(BitSetNode node, final long procId) { + private BitSetNode delete(BitSetNode node, long procId) { node = lookupClosestNode(node, procId); - assert node != null : "expected node to delete procId=" + procId; - assert node.contains(procId) : "expected procId=" + procId + " in the node"; + if (node == null || !node.contains(procId)) { + LOG.warn("The BitSetNode for procId={} does not exist, maybe a double deletion?", procId); + return node; + } node.delete(procId); if (!keepDeletes && node.isEmpty()) { // TODO: RESET if (map.size() == 1) @@ -520,41 +170,81 @@ private BitSetNode delete(BitSetNode node, final long procId) { return node; } - @InterfaceAudience.Private - public void setDeleted(final long procId, final boolean isDeleted) { + /** + * Will be called when restarting where we need to rebuild the ProcedureStoreTracker. + */ + public void setMinMaxModifiedProcIds(long min, long max) { + this.minModifiedProcId = min; + this.maxModifiedProcId = max; + } + /** + * This method is used when restarting where we need to rebuild the ProcedureStoreTracker. The + * {@link #delete(long)} method above assume that the {@link BitSetNode} exists, but when restart + * this is not true, as we will read the wal files in reverse order so a delete may come first. + */ + public void setDeleted(long procId, boolean isDeleted) { BitSetNode node = getOrCreateNode(procId); assert node.contains(procId) : "expected procId=" + procId + " in the node=" + node; node.updateState(procId, isDeleted); trackProcIds(procId); } - public void setDeletedIfSet(final long... procId) { + /** + * Set the given bit for the procId to delete if it was modified before. + *

+ * This method is used to test whether a procedure wal file can be safely deleted, as if all the + * procedures in the given procedure wal file has been modified in the new procedure wal files, + * then we can delete it. + */ + public void setDeletedIfModified(long... procId) { BitSetNode node = null; for (int i = 0; i < procId.length; ++i) { node = lookupClosestNode(node, procId[i]); - if (node != null && node.isUpdated(procId[i])) { + if (node != null && node.isModified(procId[i])) { node.delete(procId[i]); } } } - public void setDeletedIfSet(final ProcedureStoreTracker tracker) { + private void setDeleteIf(ProcedureStoreTracker tracker, + BiFunction func) { BitSetNode trackerNode = null; - for (BitSetNode node: map.values()) { - final long minProcId = node.getStart(); - final long maxProcId = node.getEnd(); + for (BitSetNode node : map.values()) { + long minProcId = node.getStart(); + long maxProcId = node.getEnd(); for (long procId = minProcId; procId <= maxProcId; ++procId) { - if (!node.isUpdated(procId)) continue; + if (!node.isModified(procId)) { + continue; + } trackerNode = tracker.lookupClosestNode(trackerNode, procId); - if (trackerNode == null || !trackerNode.contains(procId) || trackerNode.isUpdated(procId)) { - // the procedure was removed or updated + if (func.apply(trackerNode, procId)) { node.delete(procId); } } } } + /** + * For the global tracker, we will use this method to build the holdingCleanupTracker, as the + * modified flags will be cleared after rolling so we only need to test the deleted flags. + * @see #setDeletedIfModifiedInBoth(ProcedureStoreTracker) + */ + public void setDeletedIfDeletedByThem(ProcedureStoreTracker tracker) { + setDeleteIf(tracker, (node, procId) -> node == null || !node.contains(procId) || + node.isDeleted(procId) == DeleteState.YES); + } + + /** + * Similar with {@link #setDeletedIfModified(long...)}, but here the {@code procId} are given by + * the {@code tracker}. If a procedure is modified by us, and also by the given {@code tracker}, + * then we mark it as deleted. + * @see #setDeletedIfModified(long...) + */ + public void setDeletedIfModifiedInBoth(ProcedureStoreTracker tracker) { + setDeleteIf(tracker, (node, procId) -> node != null && node.isModified(procId)); + } + /** * lookup the node containing the specified procId. * @param node cached node to check before doing a lookup @@ -568,28 +258,29 @@ private BitSetNode lookupClosestNode(final BitSetNode node, final long procId) { } private void trackProcIds(long procId) { - minUpdatedProcId = Math.min(minUpdatedProcId, procId); - maxUpdatedProcId = Math.max(maxUpdatedProcId, procId); + minModifiedProcId = Math.min(minModifiedProcId, procId); + maxModifiedProcId = Math.max(maxModifiedProcId, procId); } - public long getUpdatedMinProcId() { - return minUpdatedProcId; + public long getModifiedMinProcId() { + return minModifiedProcId; } - public long getUpdatedMaxProcId() { - return maxUpdatedProcId; + public long getModifiedMaxProcId() { + return maxModifiedProcId; } public void reset() { this.keepDeletes = false; this.partial = false; this.map.clear(); - resetUpdates(); + resetModified(); } - public boolean isUpdated(long procId) { + public boolean isModified(long procId) { final Map.Entry entry = map.floorEntry(procId); - return entry != null && entry.getValue().contains(procId) && entry.getValue().isUpdated(procId); + return entry != null && entry.getValue().contains(procId) && + entry.getValue().isModified(procId); } /** @@ -604,15 +295,14 @@ public DeleteState isDeleted(long procId) { if (entry != null && entry.getValue().contains(procId)) { BitSetNode node = entry.getValue(); DeleteState state = node.isDeleted(procId); - return partial && !node.isUpdated(procId) ? DeleteState.MAYBE : state; + return partial && !node.isModified(procId) ? DeleteState.MAYBE : state; } return partial ? DeleteState.MAYBE : DeleteState.YES; } public long getActiveMinProcId() { - // TODO: Cache? Map.Entry entry = map.firstEntry(); - return entry == null ? 0 : entry.getValue().getActiveMinProcId(); + return entry == null ? Procedure.NO_PROC_ID : entry.getValue().getActiveMinProcId(); } public void setKeepDeletes(boolean keepDeletes) { @@ -656,11 +346,12 @@ public boolean isEmpty() { } /** - * @return true if any procedure was updated since last call to {@link #resetUpdates()}. + * @return true if all procedure was modified or deleted since last call to + * {@link #resetModified()}. */ - public boolean isUpdated() { + public boolean isAllModified() { for (Map.Entry entry : map.entrySet()) { - if (!entry.getValue().isUpdated()) { + if (!entry.getValue().isAllModified()) { return false; } } @@ -668,24 +359,28 @@ public boolean isUpdated() { } /** - * Clears the list of updated procedure ids. This doesn't affect global list of active - * procedure ids. + * Will be used when there are too many proc wal files. We will rewrite the states of the active + * procedures in the oldest proc wal file so that we can delete it. + * @return all the active procedure ids in this tracker. */ - public void resetUpdates() { - for (Map.Entry entry : map.entrySet()) { - entry.getValue().resetUpdates(); - } - minUpdatedProcId = Long.MAX_VALUE; - maxUpdatedProcId = Long.MIN_VALUE; + public long[] getAllActiveProcIds() { + return map.values().stream().map(BitSetNode::getActiveProcIds).filter(p -> p.length > 0) + .flatMapToLong(LongStream::of).toArray(); } - public void undeleteAll() { + /** + * Clears the list of updated procedure ids. This doesn't affect global list of active + * procedure ids. + */ + public void resetModified() { for (Map.Entry entry : map.entrySet()) { - entry.getValue().undeleteAll(); + entry.getValue().resetModified(); } + minModifiedProcId = Long.MAX_VALUE; + maxModifiedProcId = Long.MIN_VALUE; } - private BitSetNode getOrCreateNode(final long procId) { + private BitSetNode getOrCreateNode(long procId) { // If procId can fit in left node (directly or by growing it) BitSetNode leftNode = null; boolean leftCanGrow = false; @@ -760,7 +455,7 @@ private BitSetNode mergeNodes(BitSetNode leftNode, BitSetNode rightNode) { public void dump() { System.out.println("map " + map.size()); - System.out.println("isUpdated " + isUpdated()); + System.out.println("isAllModified " + isAllModified()); System.out.println("isEmpty " + isEmpty()); for (Map.Entry entry : map.entrySet()) { entry.getValue().dump(); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/CorruptedWALProcedureStoreException.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/CorruptedWALProcedureStoreException.java index dd34896ebb34..ba4480fca7e6 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/CorruptedWALProcedureStoreException.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/CorruptedWALProcedureStoreException.java @@ -15,19 +15,19 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2.store.wal; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; /** * Thrown when a procedure WAL is corrupted */ @InterfaceAudience.Private -@InterfaceStability.Stable public class CorruptedWALProcedureStoreException extends HBaseIOException { + + private static final long serialVersionUID = -3407300445435898074L; + /** default constructor */ public CorruptedWALProcedureStoreException() { super(); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFile.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFile.java index 6226350a472b..16767446e17b 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFile.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFile.java @@ -15,20 +15,18 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2.store.wal; import java.io.IOException; - import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; + import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALHeader; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALTrailer; @@ -37,7 +35,6 @@ * Describes a WAL File */ @InterfaceAudience.Private -@InterfaceStability.Evolving public class ProcedureWALFile implements Comparable { private static final Logger LOG = LoggerFactory.getLogger(ProcedureWALFile.class); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormat.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormat.java index ac3a52941e95..179c7404d95f 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormat.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormat.java @@ -18,25 +18,22 @@ package org.apache.hadoop.hbase.procedure2.store.wal; -import org.apache.hbase.thirdparty.com.google.protobuf.InvalidProtocolBufferException; - import java.io.IOException; import java.io.InputStream; import java.io.OutputStream; import java.util.Iterator; - import org.apache.hadoop.fs.FSDataInputStream; import org.apache.hadoop.fs.FSDataOutputStream; -import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.io.util.StreamUtils; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureUtil; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureLoader; import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; import org.apache.hadoop.hbase.procedure2.util.ByteSlot; +import org.apache.yetus.audience.InterfaceAudience; + +import org.apache.hbase.thirdparty.com.google.protobuf.InvalidProtocolBufferException; + import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALEntry; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALHeader; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALTrailer; @@ -45,9 +42,7 @@ * Helper class that contains the WAL serialization utils. */ @InterfaceAudience.Private -@InterfaceStability.Evolving public final class ProcedureWALFormat { - private static final Logger LOG = LoggerFactory.getLogger(ProcedureWALFormat.class); static final byte LOG_TYPE_STREAM = 0; static final byte LOG_TYPE_COMPACTED = 1; @@ -60,6 +55,9 @@ public final class ProcedureWALFormat { @InterfaceAudience.Private public static class InvalidWALDataException extends IOException { + + private static final long serialVersionUID = 5471733223070202196L; + public InvalidWALDataException(String s) { super(s); } @@ -75,9 +73,20 @@ interface Loader extends ProcedureLoader { private ProcedureWALFormat() {} - public static void load(final Iterator logs, - final ProcedureStoreTracker tracker, final Loader loader) throws IOException { - final ProcedureWALFormatReader reader = new ProcedureWALFormatReader(tracker, loader); + /** + * Load all the procedures in these ProcedureWALFiles, and rebuild the given {@code tracker} if + * needed, i.e, the {@code tracker} is a partial one. + *

+ * The method in the give {@code loader} will be called at the end after we load all the + * procedures and construct the hierarchy. + *

+ * And we will call the {@link ProcedureStoreTracker#resetModified()} method for the given + * {@code tracker} before returning, as it will be used to track the next proc wal file's modified + * procedures. + */ + public static void load(Iterator logs, ProcedureStoreTracker tracker, + Loader loader) throws IOException { + ProcedureWALFormatReader reader = new ProcedureWALFormatReader(tracker, loader); tracker.setKeepDeletes(true); try { // Ignore the last log which is current active log. @@ -93,8 +102,10 @@ public static void load(final Iterator logs, reader.finish(); // The tracker is now updated with all the procedures read from the logs - tracker.setPartialFlag(false); - tracker.resetUpdates(); + if (tracker.isPartial()) { + tracker.setPartialFlag(false); + } + tracker.resetModified(); } finally { tracker.setKeepDeletes(false); } @@ -205,7 +216,7 @@ public static ProcedureWALEntry readEntry(InputStream stream) throws IOException } public static void writeEntry(ByteSlot slot, ProcedureWALEntry.Type type, - Procedure proc, Procedure[] subprocs) throws IOException { + Procedure proc, Procedure[] subprocs) throws IOException { final ProcedureWALEntry.Builder builder = ProcedureWALEntry.newBuilder(); builder.setType(type); builder.addProcedure(ProcedureUtil.convertToProtoProcedure(proc)); @@ -217,17 +228,17 @@ public static void writeEntry(ByteSlot slot, ProcedureWALEntry.Type type, builder.build().writeDelimitedTo(slot); } - public static void writeInsert(ByteSlot slot, Procedure proc) + public static void writeInsert(ByteSlot slot, Procedure proc) throws IOException { writeEntry(slot, ProcedureWALEntry.Type.PROCEDURE_WAL_INIT, proc, null); } - public static void writeInsert(ByteSlot slot, Procedure proc, Procedure[] subprocs) + public static void writeInsert(ByteSlot slot, Procedure proc, Procedure[] subprocs) throws IOException { writeEntry(slot, ProcedureWALEntry.Type.PROCEDURE_WAL_INSERT, proc, subprocs); } - public static void writeUpdate(ByteSlot slot, Procedure proc) + public static void writeUpdate(ByteSlot slot, Procedure proc) throws IOException { writeEntry(slot, ProcedureWALEntry.Type.PROCEDURE_WAL_UPDATE, proc, null); } @@ -240,7 +251,7 @@ public static void writeDelete(ByteSlot slot, long procId) builder.build().writeDelimitedTo(slot); } - public static void writeDelete(ByteSlot slot, Procedure proc, long[] subprocs) + public static void writeDelete(ByteSlot slot, Procedure proc, long[] subprocs) throws IOException { final ProcedureWALEntry.Builder builder = ProcedureWALEntry.newBuilder(); builder.setType(ProcedureWALEntry.Type.PROCEDURE_WAL_DELETE); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormatReader.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormatReader.java index 4ab70f18e100..1b19abbeb926 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormatReader.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALFormatReader.java @@ -15,91 +15,40 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2.store.wal; -import org.apache.hbase.thirdparty.com.google.protobuf.InvalidProtocolBufferException; - import java.io.IOException; - import org.apache.hadoop.fs.FSDataInputStream; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.apache.hadoop.hbase.procedure2.Procedure; -import org.apache.hadoop.hbase.procedure2.ProcedureUtil; -import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureIterator; -import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; + +import org.apache.hbase.thirdparty.com.google.protobuf.InvalidProtocolBufferException; + import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALEntry; /** - * Helper class that loads the procedures stored in a WAL + * Helper class that loads the procedures stored in a WAL. */ @InterfaceAudience.Private -@InterfaceStability.Evolving public class ProcedureWALFormatReader { private static final Logger LOG = LoggerFactory.getLogger(ProcedureWALFormatReader.class); - // ============================================================================================== - // We read the WALs in reverse order from the newest to the oldest. - // We have different entry types: - // - INIT: Procedure submitted by the user (also known as 'root procedure') - // - INSERT: Children added to the procedure :[, ...] - // - UPDATE: The specified procedure was updated - // - DELETE: The procedure was removed (finished/rolledback and result TTL expired) - // - // In the WAL we can find multiple times the same procedure as UPDATE or INSERT. - // We read the WAL from top to bottom, so every time we find an entry of the - // same procedure, that will be the "latest" update (Caveat: with multiple threads writing - // the store, this assumption does not hold). - // - // We keep two in-memory maps: - // - localProcedureMap: is the map containing the entries in the WAL we are processing - // - procedureMap: is the map containing all the procedures we found up to the WAL in process. - // localProcedureMap is merged with the procedureMap once we reach the WAL EOF. - // - // Since we are reading the WALs in reverse order (newest to oldest), - // if we find an entry related to a procedure we already have in 'procedureMap' we can discard it. - // - // The WAL is append-only so the last procedure in the WAL is the one that - // was in execution at the time we crashed/closed the server. - // Given that, the procedure replay order can be inferred by the WAL order. - // - // Example: - // WAL-2: [A, B, A, C, D] - // WAL-1: [F, G, A, F, B] - // Replay-Order: [D, C, A, B, F, G] - // - // The "localProcedureMap" keeps a "replayOrder" list. Every time we add the - // record to the map that record is moved to the head of the "replayOrder" list. - // Using the example above: - // WAL-2 localProcedureMap.replayOrder is [D, C, A, B] - // WAL-1 localProcedureMap.replayOrder is [F, G] - // - // Each time we reach the WAL-EOF, the "replayOrder" list is merged/appended in 'procedureMap' - // so using the example above we end up with: [D, C, A, B] + [F, G] as replay order. - // - // Fast Start: INIT/INSERT record and StackIDs - // --------------------------------------------- - // We have two special records, INIT and INSERT, that track the first time - // the procedure was added to the WAL. We can use this information to be able - // to start procedures before reaching the end of the WAL, or before reading all WALs. - // But in some cases, the WAL with that record can be already gone. - // As an alternative, we can use the stackIds on each procedure, - // to identify when a procedure is ready to start. - // If there are gaps in the sum of the stackIds we need to read more WALs. - // - // Example (all procs child of A): - // WAL-2: [A, B] A stackIds = [0, 4], B stackIds = [1, 5] - // WAL-1: [A, B, C, D] - // - // In the case above we need to read one more WAL to be able to consider - // the root procedure A and all children as ready. - // ============================================================================================== - private final WalProcedureMap localProcedureMap = new WalProcedureMap(1024); - private final WalProcedureMap procedureMap = new WalProcedureMap(1024); + /** + * We will use the localProcedureMap to track the active procedures for the current proc wal file, + * and when we finished reading one proc wal file, we will merge he localProcedureMap to the + * procedureMap, which tracks the global active procedures. + *

+ * See the comments of {@link WALProcedureMap} for more details. + *

+ * After reading all the proc wal files, we will use the procedures in the procedureMap to build a + * {@link WALProcedureTree}, and then give the result to the upper layer. See the comments of + * {@link WALProcedureTree} and the code in {@link #finish()} for more details. + */ + private final WALProcedureMap localProcedureMap = new WALProcedureMap(); + private final WALProcedureMap procedureMap = new WALProcedureMap(); private final ProcedureWALFormat.Loader loader; @@ -111,33 +60,31 @@ public class ProcedureWALFormatReader { * to rebuild the tracker. */ private final ProcedureStoreTracker tracker; - // TODO: private final boolean hasFastStartSupport; /** - * If tracker for a log file is partial (see {@link ProcedureStoreTracker#partial}), we - * re-build the list of procedures updated in that WAL because we need it for log cleaning - * purposes. If all procedures updated in a WAL are found to be obsolete, it can be safely deleted. - * (see {@link WALProcedureStore#removeInactiveLogs()}). - * However, we don't need deleted part of a WAL's tracker for this purpose, so we don't bother - * re-building it. + * If tracker for a log file is partial (see {@link ProcedureStoreTracker#partial}), we re-build + * the list of procedures modified in that WAL because we need it for log cleaning purposes. If + * all procedures modified in a WAL are found to be obsolete, it can be safely deleted. (see + * {@link WALProcedureStore#removeInactiveLogs()}). + *

+ * Notice that, the deleted part for this tracker will not be global valid as we can only count + * the deletes in the current file, but it is not big problem as finally, the above tracker will + * have the global state of deleted, and it will also be used to build the cleanup tracker. */ private ProcedureStoreTracker localTracker; - // private long compactionLogId; private long maxProcId = 0; public ProcedureWALFormatReader(final ProcedureStoreTracker tracker, ProcedureWALFormat.Loader loader) { this.tracker = tracker; this.loader = loader; - // we support fast-start only if we have a clean shutdown. - // this.hasFastStartSupport = !tracker.isEmpty(); } - public void read(final ProcedureWALFile log) throws IOException { - localTracker = log.getTracker().isPartial() ? log.getTracker() : null; - if (localTracker != null) { - LOG.info("Rebuilding tracker for " + log); + public void read(ProcedureWALFile log) throws IOException { + localTracker = log.getTracker(); + if (localTracker.isPartial()) { + LOG.info("Rebuilding tracker for {}", log); } long count = 0; @@ -147,7 +94,7 @@ public void read(final ProcedureWALFile log) throws IOException { while (hasMore) { ProcedureWALEntry entry = ProcedureWALFormat.readEntry(stream); if (entry == null) { - LOG.warn("Nothing left to decode. Exiting with missing EOF, log=" + log); + LOG.warn("Nothing left to decode. Exiting with missing EOF, log={}", log); break; } count++; @@ -178,61 +125,58 @@ public void read(final ProcedureWALFile log) throws IOException { loader.markCorruptedWAL(log, e); } - if (localTracker != null) { - localTracker.setPartialFlag(false); - } if (!localProcedureMap.isEmpty()) { - log.setProcIds(localProcedureMap.getMinProcId(), localProcedureMap.getMaxProcId()); - procedureMap.mergeTail(localProcedureMap); - - //if (hasFastStartSupport) { - // TODO: Some procedure may be already runnables (see readInitEntry()) - // (we can also check the "update map" in the log trackers) - // -------------------------------------------------- - //EntryIterator iter = procedureMap.fetchReady(); - //if (iter != null) loader.load(iter); - // -------------------------------------------------- - //} + log.setProcIds(localProcedureMap.getMinModifiedProcId(), + localProcedureMap.getMaxModifiedProcId()); + if (localTracker.isPartial()) { + localTracker.setMinMaxModifiedProcIds(localProcedureMap.getMinModifiedProcId(), + localProcedureMap.getMaxModifiedProcId()); + } + procedureMap.merge(localProcedureMap); } + // Do not reset the partial flag for local tracker, as here the local tracker only know the + // procedures which are modified in this file. } public void finish() throws IOException { // notify the loader about the max proc ID loader.setMaxProcId(maxProcId); - // fetch the procedure ready to run. - ProcedureIterator procIter = procedureMap.fetchReady(); - if (procIter != null) loader.load(procIter); + // build the procedure execution tree. When building we will verify that whether a procedure is + // valid. + WALProcedureTree tree = WALProcedureTree.build(procedureMap.getProcedures()); + loader.load(tree.getValidProcs()); + loader.handleCorrupted(tree.getCorruptedProcs()); + } - // remaining procedures have missing link or dependencies - // consider them as corrupted, manual fix is probably required. - procIter = procedureMap.fetchAll(); - if (procIter != null) loader.handleCorrupted(procIter); + private void setDeletedIfPartial(ProcedureStoreTracker tracker, long procId) { + if (tracker.isPartial()) { + tracker.setDeleted(procId, true); + } } - private void loadProcedure(final ProcedureWALEntry entry, final ProcedureProtos.Procedure proc) { + private void insertIfPartial(ProcedureStoreTracker tracker, ProcedureProtos.Procedure proc) { + if (tracker.isPartial()) { + tracker.insert(proc.getProcId()); + } + } + + private void loadProcedure(ProcedureWALEntry entry, ProcedureProtos.Procedure proc) { maxProcId = Math.max(maxProcId, proc.getProcId()); if (isRequired(proc.getProcId())) { - if (LOG.isTraceEnabled()) { - LOG.trace("Read " + entry.getType() + " entry " + proc.getProcId()); - } + LOG.trace("Read {} entry {}", entry.getType(), proc.getProcId()); localProcedureMap.add(proc); - if (tracker.isPartial()) { - tracker.insert(proc.getProcId()); - } - } - if (localTracker != null) { - localTracker.insert(proc.getProcId()); + insertIfPartial(tracker, proc); } + insertIfPartial(localTracker, proc); } - private void readInitEntry(final ProcedureWALEntry entry) - throws IOException { + private void readInitEntry(ProcedureWALEntry entry) { assert entry.getProcedureCount() == 1 : "Expected only one procedure"; loadProcedure(entry, entry.getProcedure(0)); } - private void readInsertEntry(final ProcedureWALEntry entry) throws IOException { + private void readInsertEntry(ProcedureWALEntry entry) { assert entry.getProcedureCount() >= 1 : "Expected one or more procedures"; loadProcedure(entry, entry.getProcedure(0)); for (int i = 1; i < entry.getProcedureCount(); ++i) { @@ -240,12 +184,12 @@ private void readInsertEntry(final ProcedureWALEntry entry) throws IOException { } } - private void readUpdateEntry(final ProcedureWALEntry entry) throws IOException { + private void readUpdateEntry(ProcedureWALEntry entry) { assert entry.getProcedureCount() == 1 : "Expected only one procedure"; loadProcedure(entry, entry.getProcedure(0)); } - private void readDeleteEntry(final ProcedureWALEntry entry) throws IOException { + private void readDeleteEntry(ProcedureWALEntry entry) { assert entry.hasProcId() : "expected ProcID"; if (entry.getChildIdCount() > 0) { @@ -267,598 +211,19 @@ private void readDeleteEntry(final ProcedureWALEntry entry) throws IOException { } private void deleteEntry(final long procId) { - if (LOG.isTraceEnabled()) { - LOG.trace("delete entry " + procId); - } + LOG.trace("delete entry {}", procId); maxProcId = Math.max(maxProcId, procId); localProcedureMap.remove(procId); assert !procedureMap.contains(procId); - if (tracker.isPartial()) { - tracker.setDeleted(procId, true); - } - if (localTracker != null) { - // In case there is only delete entry for this procedure in current log. - localTracker.setDeleted(procId, true); - } + setDeletedIfPartial(tracker, procId); + setDeletedIfPartial(localTracker, procId); } - private boolean isDeleted(final long procId) { + private boolean isDeleted(long procId) { return tracker.isDeleted(procId) == ProcedureStoreTracker.DeleteState.YES; } - private boolean isRequired(final long procId) { + private boolean isRequired(long procId) { return !isDeleted(procId) && !procedureMap.contains(procId); } - - // ========================================================================== - // We keep an in-memory map of the procedures sorted by replay order. - // (see the details in the beginning of the file) - // _______________________________________________ - // procedureMap = | A | | E | | C | | | | | G | | | - // D B - // replayOrderHead = C <-> B <-> E <-> D <-> A <-> G - // - // We also have a lazy grouping by "root procedure", and a list of - // unlinked procedures. If after reading all the WALs we have unlinked - // procedures it means that we had a missing WAL or a corruption. - // rootHead = A <-> D <-> G - // B E - // C - // unlinkFromLinkList = None - // ========================================================================== - private static class Entry { - // For bucketed linked lists in hash-table. - protected Entry hashNext; - // child head - protected Entry childHead; - // double-link for rootHead or childHead - protected Entry linkNext; - protected Entry linkPrev; - // replay double-linked-list - protected Entry replayNext; - protected Entry replayPrev; - // procedure-infos - protected Procedure procedure; - protected ProcedureProtos.Procedure proto; - protected boolean ready = false; - - public Entry(Entry hashNext) { - this.hashNext = hashNext; - } - - public long getProcId() { - return proto.getProcId(); - } - - public long getParentId() { - return proto.getParentId(); - } - - public boolean hasParent() { - return proto.hasParentId(); - } - - public boolean isReady() { - return ready; - } - - public boolean isFinished() { - if (!hasParent()) { - // we only consider 'root' procedures. because for the user 'finished' - // means when everything up to the 'root' is finished. - switch (proto.getState()) { - case ROLLEDBACK: - case SUCCESS: - return true; - default: - break; - } - } - return false; - } - - public Procedure convert() throws IOException { - if (procedure == null) { - procedure = ProcedureUtil.convertToProcedure(proto); - } - return procedure; - } - - @Override - public String toString() { - final StringBuilder sb = new StringBuilder(); - sb.append("Entry("); - sb.append(getProcId()); - sb.append(", parentId="); - sb.append(getParentId()); - sb.append(", class="); - sb.append(proto.getClassName()); - sb.append(")"); - return sb.toString(); - } - } - - private static class EntryIterator implements ProcedureIterator { - private final Entry replayHead; - private Entry current; - - public EntryIterator(Entry replayHead) { - this.replayHead = replayHead; - this.current = replayHead; - } - - @Override - public void reset() { - this.current = replayHead; - } - - @Override - public boolean hasNext() { - return current != null; - } - - @Override - public boolean isNextFinished() { - return current != null && current.isFinished(); - } - - @Override - public void skipNext() { - current = current.replayNext; - } - - @Override - public Procedure next() throws IOException { - try { - return current.convert(); - } finally { - current = current.replayNext; - } - } - } - - private static class WalProcedureMap { - // procedure hash table - private Entry[] procedureMap; - - // replay-order double-linked-list - private Entry replayOrderHead; - private Entry replayOrderTail; - - // root linked-list - private Entry rootHead; - - // pending unlinked children (root not present yet) - private Entry childUnlinkedHead; - - // Track ProcId range - private long minProcId = Long.MAX_VALUE; - private long maxProcId = Long.MIN_VALUE; - - public WalProcedureMap(int size) { - procedureMap = new Entry[size]; - replayOrderHead = null; - replayOrderTail = null; - rootHead = null; - childUnlinkedHead = null; - } - - public void add(ProcedureProtos.Procedure procProto) { - trackProcIds(procProto.getProcId()); - Entry entry = addToMap(procProto.getProcId(), procProto.hasParentId()); - boolean newEntry = entry.proto == null; - // We have seen procedure WALs where the entries are out of order; see HBASE-18152. - // To compensate, only replace the Entry procedure if for sure this new procedure - // is indeed an entry that came later. TODO: Fix the writing of procedure info so - // it does not violate basic expectation, that WALs contain procedure changes going - // from start to finish in sequence. - if (newEntry || isIncreasing(entry.proto, procProto)) { - entry.proto = procProto; - } - addToReplayList(entry); - if(newEntry) { - if (procProto.hasParentId()) { - childUnlinkedHead = addToLinkList(entry, childUnlinkedHead); - } else { - rootHead = addToLinkList(entry, rootHead); - } - } - } - - /** - * @return True if this new procedure is 'richer' than the current one else - * false and we log this incidence where it appears that the WAL has older entries - * appended after newer ones. See HBASE-18152. - */ - private static boolean isIncreasing(ProcedureProtos.Procedure current, - ProcedureProtos.Procedure candidate) { - // Check that the procedures we see are 'increasing'. We used to compare - // procedure id first and then update time but it can legitimately go backwards if the - // procedure is failed or rolled back so that was unreliable. Was going to compare - // state but lets see if comparing update time enough (unfortunately this issue only - // seen under load...) - boolean increasing = current.getLastUpdate() <= candidate.getLastUpdate(); - if (!increasing) { - LOG.warn("NOT INCREASING! current=" + current + ", candidate=" + candidate); - } - return increasing; - } - - public boolean remove(long procId) { - trackProcIds(procId); - Entry entry = removeFromMap(procId); - if (entry != null) { - unlinkFromReplayList(entry); - unlinkFromLinkList(entry); - return true; - } - return false; - } - - private void trackProcIds(long procId) { - minProcId = Math.min(minProcId, procId); - maxProcId = Math.max(maxProcId, procId); - } - - public long getMinProcId() { - return minProcId; - } - - public long getMaxProcId() { - return maxProcId; - } - - public boolean contains(long procId) { - return getProcedure(procId) != null; - } - - public boolean isEmpty() { - return replayOrderHead == null; - } - - public void clear() { - for (int i = 0; i < procedureMap.length; ++i) { - procedureMap[i] = null; - } - replayOrderHead = null; - replayOrderTail = null; - rootHead = null; - childUnlinkedHead = null; - minProcId = Long.MAX_VALUE; - maxProcId = Long.MIN_VALUE; - } - - /* - * Merges two WalProcedureMap, - * the target is the "global" map, the source is the "local" map. - * - The entries in the hashtables are guaranteed to be unique. - * On replay we don't load procedures that already exist in the "global" - * map (the one we are merging the "local" in to). - * - The replayOrderList of the "local" nao will be appended to the "global" - * map replay list. - * - The "local" map will be cleared at the end of the operation. - */ - public void mergeTail(WalProcedureMap other) { - for (Entry p = other.replayOrderHead; p != null; p = p.replayNext) { - int slotIndex = getMapSlot(p.getProcId()); - p.hashNext = procedureMap[slotIndex]; - procedureMap[slotIndex] = p; - } - - if (replayOrderHead == null) { - replayOrderHead = other.replayOrderHead; - replayOrderTail = other.replayOrderTail; - rootHead = other.rootHead; - childUnlinkedHead = other.childUnlinkedHead; - } else { - // append replay list - assert replayOrderTail.replayNext == null; - assert other.replayOrderHead.replayPrev == null; - replayOrderTail.replayNext = other.replayOrderHead; - other.replayOrderHead.replayPrev = replayOrderTail; - replayOrderTail = other.replayOrderTail; - - // merge rootHead - if (rootHead == null) { - rootHead = other.rootHead; - } else if (other.rootHead != null) { - Entry otherTail = findLinkListTail(other.rootHead); - otherTail.linkNext = rootHead; - rootHead.linkPrev = otherTail; - rootHead = other.rootHead; - } - - // merge childUnlinkedHead - if (childUnlinkedHead == null) { - childUnlinkedHead = other.childUnlinkedHead; - } else if (other.childUnlinkedHead != null) { - Entry otherTail = findLinkListTail(other.childUnlinkedHead); - otherTail.linkNext = childUnlinkedHead; - childUnlinkedHead.linkPrev = otherTail; - childUnlinkedHead = other.childUnlinkedHead; - } - } - maxProcId = Math.max(maxProcId, other.maxProcId); - minProcId = Math.max(minProcId, other.minProcId); - - other.clear(); - } - - /* - * Returns an EntryIterator with the list of procedures ready - * to be added to the executor. - * A Procedure is ready if its children and parent are ready. - */ - public EntryIterator fetchReady() { - buildGraph(); - - Entry readyHead = null; - Entry readyTail = null; - Entry p = replayOrderHead; - while (p != null) { - Entry next = p.replayNext; - if (p.isReady()) { - unlinkFromReplayList(p); - if (readyTail != null) { - readyTail.replayNext = p; - p.replayPrev = readyTail; - } else { - p.replayPrev = null; - readyHead = p; - } - readyTail = p; - p.replayNext = null; - } - p = next; - } - // we need the hash-table lookups for parents, so this must be done - // out of the loop where we check isReadyToRun() - for (p = readyHead; p != null; p = p.replayNext) { - removeFromMap(p.getProcId()); - unlinkFromLinkList(p); - } - return readyHead != null ? new EntryIterator(readyHead) : null; - } - - /* - * Drain this map and return all procedures in it. - */ - public EntryIterator fetchAll() { - Entry head = replayOrderHead; - for (Entry p = head; p != null; p = p.replayNext) { - removeFromMap(p.getProcId()); - } - for (int i = 0; i < procedureMap.length; ++i) { - assert procedureMap[i] == null : "map not empty i=" + i; - } - replayOrderHead = null; - replayOrderTail = null; - childUnlinkedHead = null; - rootHead = null; - return head != null ? new EntryIterator(head) : null; - } - - private void buildGraph() { - Entry p = childUnlinkedHead; - while (p != null) { - Entry next = p.linkNext; - Entry rootProc = getRootProcedure(p); - if (rootProc != null) { - rootProc.childHead = addToLinkList(p, rootProc.childHead); - } - p = next; - } - - for (p = rootHead; p != null; p = p.linkNext) { - checkReadyToRun(p); - } - } - - private Entry getRootProcedure(Entry entry) { - while (entry != null && entry.hasParent()) { - entry = getProcedure(entry.getParentId()); - } - return entry; - } - - /* - * (see the comprehensive explanation in the beginning of the file) - * A Procedure is ready when parent and children are ready. - * "ready" means that we all the information that we need in-memory. - * - * Example-1: - * We have two WALs, we start reading from the newest (wal-2) - * wal-2 | C B | - * wal-1 | A B C | - * - * If C and B don't depend on A (A is not the parent), we can start them - * before reading wal-1. If B is the only one with parent A we can start C. - * We have to read one more WAL before being able to start B. - * - * How do we know with the only information in B that we are not ready. - * - easy case, the parent is missing from the global map - * - more complex case we look at the Stack IDs. - * - * The Stack-IDs are added to the procedure order as an incremental index - * tracking how many times that procedure was executed, which is equivalent - * to the number of times we wrote the procedure to the WAL. - * In the example above: - * wal-2: B has stackId = [1, 2] - * wal-1: B has stackId = [1] - * wal-1: A has stackId = [0] - * - * Since we know that the Stack-IDs are incremental for a Procedure, - * we notice that there is a gap in the stackIds of B, so something was - * executed before. - * To identify when a Procedure is ready we do the sum of the stackIds of - * the procedure and the parent. if the stackIdSum is equal to the - * sum of {1..maxStackId} then everything we need is available. - * - * Example-2 - * wal-2 | A | A stackIds = [0, 2] - * wal-1 | A B | B stackIds = [1] - * - * There is a gap between A stackIds so something was executed in between. - */ - private boolean checkReadyToRun(Entry rootEntry) { - assert !rootEntry.hasParent() : "expected root procedure, got " + rootEntry; - - if (rootEntry.isFinished()) { - // If the root procedure is finished, sub-procedures should be gone - if (rootEntry.childHead != null) { - LOG.error("unexpected active children for root-procedure: " + rootEntry); - for (Entry p = rootEntry.childHead; p != null; p = p.linkNext) { - LOG.error("unexpected active children: " + p); - } - } - - assert rootEntry.childHead == null : "unexpected children on root completion. " + rootEntry; - rootEntry.ready = true; - return true; - } - - int stackIdSum = 0; - int maxStackId = 0; - for (int i = 0; i < rootEntry.proto.getStackIdCount(); ++i) { - int stackId = 1 + rootEntry.proto.getStackId(i); - maxStackId = Math.max(maxStackId, stackId); - stackIdSum += stackId; - if (LOG.isTraceEnabled()) { - LOG.trace("stackId=" + stackId + " stackIdSum=" + stackIdSum + - " maxStackid=" + maxStackId + " " + rootEntry); - } - } - - for (Entry p = rootEntry.childHead; p != null; p = p.linkNext) { - for (int i = 0; i < p.proto.getStackIdCount(); ++i) { - int stackId = 1 + p.proto.getStackId(i); - maxStackId = Math.max(maxStackId, stackId); - stackIdSum += stackId; - if (LOG.isTraceEnabled()) { - LOG.trace("stackId=" + stackId + " stackIdSum=" + stackIdSum + - " maxStackid=" + maxStackId + " " + p); - } - } - } - // The cmpStackIdSum is this formula for finding the sum of a series of numbers: - // http://www.wikihow.com/Sum-the-Integers-from-1-to-N#/Image:Sum-the-Integers-from-1-to-N-Step-2-Version-3.jpg - final int cmpStackIdSum = (maxStackId * (maxStackId + 1) / 2); - if (cmpStackIdSum == stackIdSum) { - rootEntry.ready = true; - for (Entry p = rootEntry.childHead; p != null; p = p.linkNext) { - p.ready = true; - } - return true; - } - return false; - } - - private void unlinkFromReplayList(Entry entry) { - if (replayOrderHead == entry) { - replayOrderHead = entry.replayNext; - } - if (replayOrderTail == entry) { - replayOrderTail = entry.replayPrev; - } - if (entry.replayPrev != null) { - entry.replayPrev.replayNext = entry.replayNext; - } - if (entry.replayNext != null) { - entry.replayNext.replayPrev = entry.replayPrev; - } - } - - private void addToReplayList(final Entry entry) { - unlinkFromReplayList(entry); - entry.replayNext = replayOrderHead; - entry.replayPrev = null; - if (replayOrderHead != null) { - replayOrderHead.replayPrev = entry; - } else { - replayOrderTail = entry; - } - replayOrderHead = entry; - } - - private void unlinkFromLinkList(Entry entry) { - if (entry == rootHead) { - rootHead = entry.linkNext; - } else if (entry == childUnlinkedHead) { - childUnlinkedHead = entry.linkNext; - } - if (entry.linkPrev != null) { - entry.linkPrev.linkNext = entry.linkNext; - } - if (entry.linkNext != null) { - entry.linkNext.linkPrev = entry.linkPrev; - } - } - - private Entry addToLinkList(Entry entry, Entry linkHead) { - unlinkFromLinkList(entry); - entry.linkNext = linkHead; - entry.linkPrev = null; - if (linkHead != null) { - linkHead.linkPrev = entry; - } - return entry; - } - - private Entry findLinkListTail(Entry linkHead) { - Entry tail = linkHead; - while (tail.linkNext != null) { - tail = tail.linkNext; - } - return tail; - } - - private Entry addToMap(final long procId, final boolean hasParent) { - int slotIndex = getMapSlot(procId); - Entry entry = getProcedure(slotIndex, procId); - if (entry != null) return entry; - - entry = new Entry(procedureMap[slotIndex]); - procedureMap[slotIndex] = entry; - return entry; - } - - private Entry removeFromMap(final long procId) { - int slotIndex = getMapSlot(procId); - Entry prev = null; - Entry entry = procedureMap[slotIndex]; - while (entry != null) { - if (procId == entry.getProcId()) { - if (prev != null) { - prev.hashNext = entry.hashNext; - } else { - procedureMap[slotIndex] = entry.hashNext; - } - entry.hashNext = null; - return entry; - } - prev = entry; - entry = entry.hashNext; - } - return null; - } - - private Entry getProcedure(final long procId) { - return getProcedure(getMapSlot(procId), procId); - } - - private Entry getProcedure(final int slotIndex, final long procId) { - Entry entry = procedureMap[slotIndex]; - while (entry != null) { - if (procId == entry.getProcId()) { - return entry; - } - entry = entry.hashNext; - } - return null; - } - - private int getMapSlot(final long procId) { - return (int)(Procedure.getProcIdHashCode(procId) % procedureMap.length); - } - } } diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALPrettyPrinter.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALPrettyPrinter.java index 582db77beaf4..3afcd16411ca 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALPrettyPrinter.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/ProcedureWALPrettyPrinter.java @@ -21,7 +21,6 @@ import java.io.PrintStream; import java.util.ArrayList; import java.util.List; - import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.conf.Configured; import org.apache.hadoop.fs.FSDataInputStream; @@ -30,22 +29,23 @@ import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HBaseInterfaceAudience; -import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureUtil; -import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALEntry; -import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALHeader; import org.apache.hadoop.util.Tool; import org.apache.hadoop.util.ToolRunner; +import org.apache.yetus.audience.InterfaceAudience; +import org.apache.yetus.audience.InterfaceStability; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; import org.apache.hbase.thirdparty.org.apache.commons.cli.CommandLine; +import org.apache.hbase.thirdparty.org.apache.commons.cli.DefaultParser; import org.apache.hbase.thirdparty.org.apache.commons.cli.HelpFormatter; import org.apache.hbase.thirdparty.org.apache.commons.cli.Options; import org.apache.hbase.thirdparty.org.apache.commons.cli.ParseException; -import org.apache.hbase.thirdparty.org.apache.commons.cli.PosixParser; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALEntry; +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALHeader; /** * ProcedureWALPrettyPrinter prints the contents of a given ProcedureWAL file @@ -164,7 +164,7 @@ public int run(final String[] args) throws IOException { final List files = new ArrayList<>(); try { - CommandLine cmd = new PosixParser().parse(options, args); + CommandLine cmd = new DefaultParser().parse(options, args); if (cmd.hasOption("f")) { files.add(new Path(cmd.getOptionValue("f"))); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureMap.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureMap.java new file mode 100644 index 000000000000..9cda1bcc555c --- /dev/null +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureMap.java @@ -0,0 +1,132 @@ +/** + * 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.procedure2.store.wal; + +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import org.apache.yetus.audience.InterfaceAudience; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; + +/** + * This class is used to track the active procedures when loading procedures from proc wal file. + *

+ * We will read proc wal files from new to old, but when reading a proc wal file, we will still read + * from top to bottom, so there are two groups of methods for this class. + *

+ * The first group is {@link #add(ProcedureProtos.Procedure)} and {@link #remove(long)}. It is used + * when reading a proc wal file. In these methods, for the same procedure, typically the one comes + * later should win, please see the comment for + * {@link #isIncreasing(ProcedureProtos.Procedure, ProcedureProtos.Procedure)} to see the + * exceptions. + *

+ * The second group is {@link #merge(WALProcedureMap)}. We will have a global + * {@link WALProcedureMap} to hold global the active procedures, and a local {@link WALProcedureMap} + * to hold the active procedures for the current proc wal file. And when we finish reading a proc + * wal file, we will merge the local one into the global one, by calling the + * {@link #merge(WALProcedureMap)} method of the global one and pass the local one in. In this + * method, for the same procedure, the one comes earlier will win, as we read the proc wal files + * from new to old(the reverse order). + */ +@InterfaceAudience.Private +class WALProcedureMap { + + private static final Logger LOG = LoggerFactory.getLogger(WALProcedureMap.class); + + private final Map procMap = new HashMap<>(); + + private long minModifiedProcId = Long.MAX_VALUE; + + private long maxModifiedProcId = Long.MIN_VALUE; + + private void trackProcId(long procId) { + minModifiedProcId = Math.min(minModifiedProcId, procId); + maxModifiedProcId = Math.max(maxModifiedProcId, procId); + } + + /** + * @return True if this new procedure is 'richer' than the current one else false and we log this + * incidence where it appears that the WAL has older entries appended after newer ones. + * See HBASE-18152. + */ + private static boolean isIncreasing(ProcedureProtos.Procedure current, + ProcedureProtos.Procedure candidate) { + // Check that the procedures we see are 'increasing'. We used to compare + // procedure id first and then update time but it can legitimately go backwards if the + // procedure is failed or rolled back so that was unreliable. Was going to compare + // state but lets see if comparing update time enough (unfortunately this issue only + // seen under load...) + boolean increasing = current.getLastUpdate() <= candidate.getLastUpdate(); + if (!increasing) { + LOG.warn("NOT INCREASING! current=" + current + ", candidate=" + candidate); + } + return increasing; + } + + public void add(ProcedureProtos.Procedure proc) { + procMap.compute(proc.getProcId(), (procId, existingProc) -> { + if (existingProc == null || isIncreasing(existingProc, proc)) { + return proc; + } else { + return existingProc; + } + }); + trackProcId(proc.getProcId()); + } + + public void remove(long procId) { + procMap.remove(procId); + } + + public boolean isEmpty() { + return procMap.isEmpty(); + } + + public boolean contains(long procId) { + return procMap.containsKey(procId); + } + + /** + * Merge the given {@link WALProcedureMap} into this one. The {@link WALProcedureMap} passed in + * will be cleared after merging. + */ + public void merge(WALProcedureMap other) { + other.procMap.forEach(procMap::putIfAbsent); + maxModifiedProcId = Math.max(maxModifiedProcId, other.maxModifiedProcId); + minModifiedProcId = Math.max(minModifiedProcId, other.minModifiedProcId); + other.procMap.clear(); + other.maxModifiedProcId = Long.MIN_VALUE; + other.minModifiedProcId = Long.MAX_VALUE; + } + + public Collection getProcedures() { + return Collections.unmodifiableCollection(procMap.values()); + } + + public long getMinModifiedProcId() { + return minModifiedProcId; + } + + public long getMaxModifiedProcId() { + return maxModifiedProcId; + } +} diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureStore.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureStore.java index 7d5d6d244888..afde41bdfc8f 100644 --- a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureStore.java +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureStore.java @@ -15,14 +15,12 @@ * See the License for the specific language governing permissions and * limitations under the License. */ - package org.apache.hadoop.hbase.procedure2.store.wal; import java.io.FileNotFoundException; import java.io.IOException; import java.util.ArrayList; import java.util.Arrays; -import java.util.Collections; import java.util.Comparator; import java.util.HashSet; import java.util.Iterator; @@ -35,7 +33,6 @@ import java.util.concurrent.atomic.AtomicReference; import java.util.concurrent.locks.Condition; import java.util.concurrent.locks.ReentrantLock; - import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FSDataOutputStream; import org.apache.hadoop.fs.FileAlreadyExistsException; @@ -48,29 +45,69 @@ import org.apache.hadoop.hbase.log.HBaseMarkers; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreBase; import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; import org.apache.hadoop.hbase.procedure2.util.ByteSlot; import org.apache.hadoop.hbase.procedure2.util.StringUtils; -import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALHeader; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.Threads; import org.apache.hadoop.ipc.RemoteException; import org.apache.yetus.audience.InterfaceAudience; -import org.apache.yetus.audience.InterfaceStability; import org.slf4j.Logger; import org.slf4j.LoggerFactory; + import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.hbase.thirdparty.org.apache.commons.collections4.queue.CircularFifoQueue; +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureWALHeader; /** * WAL implementation of the ProcedureStore. + *

+ * When starting, the upper layer will first call {@link #start(int)}, then {@link #recoverLease()}, + * then {@link #load(ProcedureLoader)}. + *

+ * In {@link #recoverLease()}, we will get the lease by closing all the existing wal files(by + * calling recoverFileLease), and creating a new wal writer. And we will also get the list of all + * the old wal files. + *

+ * FIXME: notice that the current recover lease implementation is problematic, it can not deal with + * the races if there are two master both wants to acquire the lease... + *

+ * In {@link #load(ProcedureLoader)} method, we will load all the active procedures. See the + * comments of this method for more details. + *

+ * The actual logging way is a bit like our FileSystem based WAL implementation as RS side. There is + * a {@link #slots}, which is more like the ring buffer, and in the insert, update and delete + * methods we will put thing into the {@link #slots} and wait. And there is a background sync + * thread(see the {@link #syncLoop()} method) which get data from the {@link #slots} and write them + * to the FileSystem, and notify the caller that we have finished. + *

+ * TODO: try using disruptor to increase performance and simplify the logic? + *

+ * The {@link #storeTracker} keeps track of the modified procedures in the newest wal file, which is + * also the one being written currently. And the deleted bits in it are for all the procedures, not + * only the ones in the newest wal file. And when rolling a log, we will first store it in the + * trailer of the current wal file, and then reset its modified bits, so that it can start to track + * the modified procedures for the new wal file. + *

+ * The {@link #holdingCleanupTracker} is used to test whether we are safe to delete the oldest wal + * file. When there are log rolling and there are more than 1 wal files, we will make use of it. It + * will first be initialized to the oldest file's tracker(which is stored in the trailer), using the + * method {@link ProcedureStoreTracker#resetTo(ProcedureStoreTracker, boolean)}, and then merge it + * with the tracker of every newer wal files, using the + * {@link ProcedureStoreTracker#setDeletedIfModifiedInBoth(ProcedureStoreTracker)}. + * If we find out + * that all the modified procedures for the oldest wal file are modified or deleted in newer wal + * files, then we can delete it. This is because that, every time we call + * {@link ProcedureStore#insert(Procedure[])} or {@link ProcedureStore#update(Procedure)}, we will + * persist the full state of a Procedure, so the earlier wal records for this procedure can all be + * deleted. * @see ProcedureWALPrettyPrinter for printing content of a single WAL. * @see #main(String[]) to parse a directory of MasterWALProcs. */ @InterfaceAudience.Private -@InterfaceStability.Evolving public class WALProcedureStore extends ProcedureStoreBase { private static final Logger LOG = LoggerFactory.getLogger(WALProcedureStore.class); public static final String LOG_PREFIX = "pv2-"; @@ -84,7 +121,7 @@ public interface LeaseRecovery { public static final String WAL_COUNT_WARN_THRESHOLD_CONF_KEY = "hbase.procedure.store.wal.warn.threshold"; - private static final int DEFAULT_WAL_COUNT_WARN_THRESHOLD = 64; + private static final int DEFAULT_WAL_COUNT_WARN_THRESHOLD = 10; public static final String EXEC_WAL_CLEANUP_ON_LOAD_CONF_KEY = "hbase.procedure.store.wal.exec.cleanup.on.load"; @@ -166,7 +203,7 @@ public interface LeaseRecovery { private int syncWaitMsec; // Variables used for UI display - private CircularFifoQueue syncMetricsQueue; + private CircularFifoQueue syncMetricsQueue; public static class SyncMetrics { private long timestamp; @@ -228,11 +265,9 @@ public WALProcedureStore(final Configuration conf, final Path walDir, final Path // Create archive dir up front. Rename won't work w/o it up on HDFS. if (this.walArchiveDir != null && !this.fs.exists(this.walArchiveDir)) { if (this.fs.mkdirs(this.walArchiveDir)) { - if (LOG.isDebugEnabled()) { - LOG.debug("Created Procedure Store WAL archive dir " + this.walArchiveDir); - } + LOG.debug("Created Procedure Store WAL archive dir {}", this.walArchiveDir); } else { - LOG.warn("Failed create of " + this.walArchiveDir); + LOG.warn("Failed create of {}", this.walArchiveDir); } } } @@ -248,7 +283,7 @@ public void start(int numSlots) throws IOException { runningProcCount = numSlots; syncMaxSlot = numSlots; slots = new ByteSlot[numSlots]; - slotsCache = new LinkedTransferQueue(); + slotsCache = new LinkedTransferQueue<>(); while (slotsCache.size() < numSlots) { slotsCache.offer(new ByteSlot()); } @@ -267,7 +302,7 @@ public void start(int numSlots) throws IOException { useHsync = conf.getBoolean(USE_HSYNC_CONF_KEY, DEFAULT_USE_HSYNC); // WebUI - syncMetricsQueue = new CircularFifoQueue( + syncMetricsQueue = new CircularFifoQueue<>( conf.getInt(STORE_WAL_SYNC_STATS_COUNT, DEFAULT_SYNC_STATS_COUNT)); // Init sync thread @@ -309,7 +344,7 @@ public void stop(final boolean abort) { } // Close the writer - closeCurrentLogStream(); + closeCurrentLogStream(abort); // Close the old logs // they should be already closed, this is just in case the load fails @@ -364,7 +399,7 @@ public Set getCorruptedLogs() { public void recoverLease() throws IOException { lock.lock(); try { - LOG.trace("Starting WAL Procedure Store lease recovery"); + LOG.debug("Starting WAL Procedure Store lease recovery"); boolean afterFirstAttempt = false; while (isRunning()) { // Don't sleep before first attempt @@ -394,14 +429,12 @@ public void recoverLease() throws IOException { // We have the lease on the log oldLogs = getLogFiles(); if (getMaxLogId(oldLogs) > flushLogId) { - if (LOG.isDebugEnabled()) { - LOG.debug("Someone else created new logs. Expected maxLogId < " + flushLogId); - } + LOG.debug("Someone else created new logs. Expected maxLogId < {}", flushLogId); logs.getLast().removeFile(this.walArchiveDir); continue; } - LOG.trace("Lease acquired for flushLogId={}", flushLogId); + LOG.debug("Lease acquired for flushLogId={}", flushLogId); break; } } finally { @@ -410,7 +443,7 @@ public void recoverLease() throws IOException { } @Override - public void load(final ProcedureLoader loader) throws IOException { + public void load(ProcedureLoader loader) throws IOException { lock.lock(); try { if (logs.isEmpty()) { @@ -419,13 +452,13 @@ public void load(final ProcedureLoader loader) throws IOException { // Nothing to do, If we have only the current log. if (logs.size() == 1) { - LOG.trace("No state logs to replay."); + LOG.debug("No state logs to replay."); loader.setMaxProcId(0); return; } // Load the old logs - final Iterator it = logs.descendingIterator(); + Iterator it = logs.descendingIterator(); it.next(); // Skip the current log ProcedureWALFormat.load(it, storeTracker, new ProcedureWALFormat.Loader() { @@ -468,7 +501,9 @@ public void markCorruptedWAL(ProcedureWALFile log, IOException e) { private void tryCleanupLogsOnLoad() { // nothing to cleanup. - if (logs.size() <= 1) return; + if (logs.size() <= 1) { + return; + } // the config says to not cleanup wals on load. if (!conf.getBoolean(EXEC_WAL_CLEANUP_ON_LOAD_CONF_KEY, @@ -485,7 +520,7 @@ private void tryCleanupLogsOnLoad() { } @Override - public void insert(final Procedure proc, final Procedure[] subprocs) { + public void insert(Procedure proc, Procedure[] subprocs) { if (LOG.isTraceEnabled()) { LOG.trace("Insert " + proc + ", subproc=" + Arrays.toString(subprocs)); } @@ -519,7 +554,7 @@ public void insert(final Procedure proc, final Procedure[] subprocs) { } @Override - public void insert(final Procedure[] procs) { + public void insert(Procedure[] procs) { if (LOG.isTraceEnabled()) { LOG.trace("Insert " + Arrays.toString(procs)); } @@ -548,7 +583,7 @@ public void insert(final Procedure[] procs) { } @Override - public void update(final Procedure proc) { + public void update(Procedure proc) { if (LOG.isTraceEnabled()) { LOG.trace("Update " + proc); } @@ -571,11 +606,8 @@ public void update(final Procedure proc) { } @Override - public void delete(final long procId) { - if (LOG.isTraceEnabled()) { - LOG.trace("Delete " + procId); - } - + public void delete(long procId) { + LOG.trace("Delete {}", procId); ByteSlot slot = acquireSlot(); try { // Serialize the delete @@ -594,7 +626,7 @@ public void delete(final long procId) { } @Override - public void delete(final Procedure proc, final long[] subProcIds) { + public void delete(Procedure proc, long[] subProcIds) { assert proc != null : "expected a non-null procedure"; assert subProcIds != null && subProcIds.length > 0 : "expected subProcIds"; if (LOG.isTraceEnabled()) { @@ -630,7 +662,7 @@ public void delete(final long[] procIds, final int offset, final int count) { } } - private void delete(final long[] procIds) { + private void delete(long[] procIds) { if (LOG.isTraceEnabled()) { LOG.trace("Delete " + Arrays.toString(procIds)); } @@ -736,20 +768,20 @@ private void updateStoreTracker(final PushType type, storeTracker.insert(subProcIds); } else { storeTracker.insert(procId, subProcIds); - holdingCleanupTracker.setDeletedIfSet(procId); + holdingCleanupTracker.setDeletedIfModified(procId); } break; case UPDATE: storeTracker.update(procId); - holdingCleanupTracker.setDeletedIfSet(procId); + holdingCleanupTracker.setDeletedIfModified(procId); break; case DELETE: if (subProcIds != null && subProcIds.length > 0) { storeTracker.delete(subProcIds); - holdingCleanupTracker.setDeletedIfSet(subProcIds); + holdingCleanupTracker.setDeletedIfModified(subProcIds); } else { storeTracker.delete(procId); - holdingCleanupTracker.setDeletedIfSet(procId); + holdingCleanupTracker.setDeletedIfModified(procId); } break; default: @@ -942,7 +974,7 @@ public long getMillisFromLastRoll() { } @VisibleForTesting - protected void periodicRollForTesting() throws IOException { + void periodicRollForTesting() throws IOException { lock.lock(); try { periodicRoll(); @@ -952,7 +984,7 @@ protected void periodicRollForTesting() throws IOException { } @VisibleForTesting - protected boolean rollWriterForTesting() throws IOException { + public boolean rollWriterForTesting() throws IOException { lock.lock(); try { return rollWriter(); @@ -962,7 +994,7 @@ protected boolean rollWriterForTesting() throws IOException { } @VisibleForTesting - protected void removeInactiveLogsForTesting() throws Exception { + void removeInactiveLogsForTesting() throws Exception { lock.lock(); try { removeInactiveLogs(); @@ -973,17 +1005,13 @@ protected void removeInactiveLogsForTesting() throws Exception { private void periodicRoll() throws IOException { if (storeTracker.isEmpty()) { - if (LOG.isTraceEnabled()) { - LOG.trace("no active procedures"); - } + LOG.trace("no active procedures"); tryRollWriter(); - removeAllLogs(flushLogId - 1); + removeAllLogs(flushLogId - 1, "no active procedures"); } else { - if (storeTracker.isUpdated()) { - if (LOG.isTraceEnabled()) { - LOG.trace("all the active procedures are in the latest log"); - } - removeAllLogs(flushLogId - 1); + if (storeTracker.isAllModified()) { + LOG.trace("all the active procedures are in the latest log"); + removeAllLogs(flushLogId - 1, "all the active procedures are in the latest log"); } // if the log size has exceeded the roll threshold @@ -997,18 +1025,20 @@ private void periodicRoll() throws IOException { } private boolean rollWriter() throws IOException { - if (!isRunning()) return false; + if (!isRunning()) { + return false; + } // Create new state-log if (!rollWriter(flushLogId + 1)) { - LOG.warn("someone else has already created log " + flushLogId); + LOG.warn("someone else has already created log {}", flushLogId); return false; } // We have the lease on the log, // but we should check if someone else has created new files if (getMaxLogId(getLogFiles()) > flushLogId) { - LOG.warn("Someone else created new logs. Expected maxLogId < " + flushLogId); + LOG.warn("Someone else created new logs. Expected maxLogId < {}", flushLogId); logs.getLast().removeFile(this.walArchiveDir); return false; } @@ -1018,7 +1048,7 @@ private boolean rollWriter() throws IOException { } @VisibleForTesting - boolean rollWriter(final long logId) throws IOException { + boolean rollWriter(long logId) throws IOException { assert logId > flushLogId : "logId=" + logId + " flushLogId=" + flushLogId; assert lock.isHeldByCurrentThread() : "expected to be the lock owner. " + lock.isLocked(); @@ -1036,10 +1066,10 @@ boolean rollWriter(final long logId) throws IOException { try { newStream = CommonFSUtils.createForWal(fs, newLogFile, false); } catch (FileAlreadyExistsException e) { - LOG.error("Log file with id=" + logId + " already exists", e); + LOG.error("Log file with id={} already exists", logId, e); return false; } catch (RemoteException re) { - LOG.warn("failed to create log file with id=" + logId, re); + LOG.warn("failed to create log file with id={}", logId, re); return false; } // After we create the stream but before we attempt to use it at all @@ -1062,9 +1092,9 @@ boolean rollWriter(final long logId) throws IOException { return false; } - closeCurrentLogStream(); + closeCurrentLogStream(false); - storeTracker.resetUpdates(); + storeTracker.resetModified(); stream = newStream; flushLogId = logId; totalSynced.set(0); @@ -1076,28 +1106,40 @@ boolean rollWriter(final long logId) throws IOException { if (logs.size() == 2) { buildHoldingCleanupTracker(); } else if (logs.size() > walCountWarnThreshold) { - LOG.warn("procedure WALs count=" + logs.size() + - " above the warning threshold " + walCountWarnThreshold + - ". check running procedures to see if something is stuck."); + LOG.warn("procedure WALs count={} above the warning threshold {}. check running procedures" + + " to see if something is stuck.", logs.size(), walCountWarnThreshold); + // This is just like what we have done at RS side when there are too many wal files. For RS, + // if there are too many wal files, we will find out the wal entries in the oldest file, and + // tell the upper layer to flush these regions so the wal entries will be useless and then we + // can delete the wal file. For WALProcedureStore, the assumption is that, if all the + // procedures recorded in a proc wal file are modified or deleted in a new proc wal file, then + // we are safe to delete it. So here if there are too many proc wal files, we will find out + // the procedure ids in the oldest file, which are neither modified nor deleted in newer proc + // wal files, and tell upper layer to update the state of these procedures to the newest proc + // wal file(by calling ProcedureStore.update), then we are safe to delete the oldest proc wal + // file. + sendForceUpdateSignal(holdingCleanupTracker.getAllActiveProcIds()); } LOG.info("Rolled new Procedure Store WAL, id={}", logId); return true; } - private void closeCurrentLogStream() { + private void closeCurrentLogStream(boolean abort) { if (stream == null || logs.isEmpty()) { return; } try { ProcedureWALFile log = logs.getLast(); - log.setProcIds(storeTracker.getUpdatedMinProcId(), storeTracker.getUpdatedMaxProcId()); + log.setProcIds(storeTracker.getModifiedMinProcId(), storeTracker.getModifiedMaxProcId()); log.updateLocalTracker(storeTracker); - long trailerSize = ProcedureWALFormat.writeTrailer(stream, storeTracker); - log.addToSize(trailerSize); + if (!abort) { + long trailerSize = ProcedureWALFormat.writeTrailer(stream, storeTracker); + log.addToSize(trailerSize); + } } catch (IOException e) { - LOG.warn("Unable to write the trailer: " + e.getMessage()); + LOG.warn("Unable to write the trailer", e); } try { stream.close(); @@ -1114,6 +1156,7 @@ private void removeInactiveLogs() throws IOException { // We keep track of which procedures are holding the oldest WAL in 'holdingCleanupTracker'. // once there is nothing olding the oldest WAL we can remove it. while (logs.size() > 1 && holdingCleanupTracker.isEmpty()) { + LOG.info("Remove the oldest log {}", logs.getFirst()); removeLogFile(logs.getFirst(), walArchiveDir); buildHoldingCleanupTracker(); } @@ -1130,26 +1173,39 @@ private void buildHoldingCleanupTracker() { } // compute the holding tracker. - // - the first WAL is used for the 'updates' - // - the other WALs are scanned to remove procs already in other wals. - // TODO: exit early if holdingCleanupTracker.isEmpty() + // - the first WAL is used for the 'updates' + // - the global tracker will be used to determine whether a procedure has been deleted + // - other trackers will be used to determine whether a procedure has been updated, as a deleted + // procedure can always be detected by checking the global tracker, we can save the deleted + // checks when applying other trackers holdingCleanupTracker.resetTo(logs.getFirst().getTracker(), true); - holdingCleanupTracker.setDeletedIfSet(storeTracker); - for (int i = 1, size = logs.size() - 1; i < size; ++i) { - holdingCleanupTracker.setDeletedIfSet(logs.get(i).getTracker()); + holdingCleanupTracker.setDeletedIfDeletedByThem(storeTracker); + // the logs is a linked list, so avoid calling get(index) on it. + Iterator iter = logs.iterator(); + // skip the tracker for the first file when creating the iterator. + iter.next(); + ProcedureStoreTracker tracker = iter.next().getTracker(); + // testing iter.hasNext after calling iter.next to skip applying the tracker for last file, + // which is just the storeTracker above. + while (iter.hasNext()) { + holdingCleanupTracker.setDeletedIfModifiedInBoth(tracker); + if (holdingCleanupTracker.isEmpty()) { + break; + } + iter.next(); } } /** * Remove all logs with logId <= {@code lastLogId}. */ - private void removeAllLogs(long lastLogId) { - if (logs.size() <= 1) return; - - if (LOG.isTraceEnabled()) { - LOG.trace("Remove all state logs with ID less than " + lastLogId); + private void removeAllLogs(long lastLogId, String why) { + if (logs.size() <= 1) { + return; } + LOG.info("Remove all state logs with ID less than {}, since {}", lastLogId, why); + boolean removed = false; while (logs.size() > 1) { ProcedureWALFile log = logs.getFirst(); @@ -1167,14 +1223,10 @@ private void removeAllLogs(long lastLogId) { private boolean removeLogFile(final ProcedureWALFile log, final Path walArchiveDir) { try { - if (LOG.isTraceEnabled()) { - LOG.trace("Removing log=" + log); - } + LOG.trace("Removing log={}", log); log.removeFile(walArchiveDir); logs.remove(log); - if (LOG.isDebugEnabled()) { - LOG.info("Removed log=" + log + ", activeLogs=" + logs); - } + LOG.debug("Removed log={}, activeLogs={}", log, logs); assert logs.size() > 0 : "expected at least one log"; } catch (IOException e) { LOG.error("Unable to remove log: " + log, e); @@ -1238,50 +1290,53 @@ private FileStatus[] getLogFiles() throws IOException { } } - private static long getMaxLogId(final FileStatus[] logFiles) { - long maxLogId = 0; - if (logFiles != null && logFiles.length > 0) { - for (int i = 0; i < logFiles.length; ++i) { - maxLogId = Math.max(maxLogId, getLogIdFromName(logFiles[i].getPath().getName())); - } + /** + * Make sure that the file set are gotten by calling {@link #getLogFiles()}, where we will sort + * the file set by log id. + * @return Max-LogID of the specified log file set + */ + private static long getMaxLogId(FileStatus[] logFiles) { + if (logFiles == null || logFiles.length == 0) { + return 0L; } - return maxLogId; + return getLogIdFromName(logFiles[logFiles.length - 1].getPath().getName()); } /** + * Make sure that the file set are gotten by calling {@link #getLogFiles()}, where we will sort + * the file set by log id. * @return Max-LogID of the specified log file set */ - private long initOldLogs(final FileStatus[] logFiles) throws IOException { - this.logs.clear(); - + private long initOldLogs(FileStatus[] logFiles) throws IOException { + if (logFiles == null || logFiles.length == 0) { + return 0L; + } long maxLogId = 0; - if (logFiles != null && logFiles.length > 0) { - for (int i = 0; i < logFiles.length; ++i) { - final Path logPath = logFiles[i].getPath(); - leaseRecovery.recoverFileLease(fs, logPath); - if (!isRunning()) { - throw new IOException("wal aborting"); - } + for (int i = 0; i < logFiles.length; ++i) { + final Path logPath = logFiles[i].getPath(); + leaseRecovery.recoverFileLease(fs, logPath); + if (!isRunning()) { + throw new IOException("wal aborting"); + } - maxLogId = Math.max(maxLogId, getLogIdFromName(logPath.getName())); - ProcedureWALFile log = initOldLog(logFiles[i], this.walArchiveDir); - if (log != null) { - this.logs.add(log); - } + maxLogId = Math.max(maxLogId, getLogIdFromName(logPath.getName())); + ProcedureWALFile log = initOldLog(logFiles[i], this.walArchiveDir); + if (log != null) { + this.logs.add(log); } - Collections.sort(this.logs); - initTrackerFromOldLogs(); } + initTrackerFromOldLogs(); return maxLogId; } /** - * If last log's tracker is not null, use it as {@link #storeTracker}. - * Otherwise, set storeTracker as partial, and let {@link ProcedureWALFormatReader} rebuild - * it using entries in the log. + * If last log's tracker is not null, use it as {@link #storeTracker}. Otherwise, set storeTracker + * as partial, and let {@link ProcedureWALFormatReader} rebuild it using entries in the log. */ private void initTrackerFromOldLogs() { - if (logs.isEmpty() || !isRunning()) return; + if (logs.isEmpty() || !isRunning()) { + return; + } ProcedureWALFile log = logs.getLast(); if (!log.getTracker().isPartial()) { storeTracker.resetTo(log.getTracker()); @@ -1295,20 +1350,18 @@ private void initTrackerFromOldLogs() { * Loads given log file and it's tracker. */ private ProcedureWALFile initOldLog(final FileStatus logFile, final Path walArchiveDir) - throws IOException { + throws IOException { final ProcedureWALFile log = new ProcedureWALFile(fs, logFile); if (logFile.getLen() == 0) { - LOG.warn("Remove uninitialized log: " + logFile); + LOG.warn("Remove uninitialized log: {}", logFile); log.removeFile(walArchiveDir); return null; } - if (LOG.isDebugEnabled()) { - LOG.debug("Opening Pv2 " + logFile); - } + LOG.debug("Opening Pv2 {}", logFile); try { log.open(); } catch (ProcedureWALFormat.InvalidWALDataException e) { - LOG.warn("Remove uninitialized log: " + logFile, e); + LOG.warn("Remove uninitialized log: {}", logFile, e); log.removeFile(walArchiveDir); return null; } catch (IOException e) { @@ -1322,7 +1375,7 @@ private ProcedureWALFile initOldLog(final FileStatus logFile, final Path walArch } catch (IOException e) { log.getTracker().reset(); log.getTracker().setPartialFlag(true); - LOG.warn("Unable to read tracker for " + log + " - " + e.getMessage()); + LOG.warn("Unable to read tracker for {}", log, e); } log.close(); @@ -1350,7 +1403,7 @@ public void recoverFileLease(FileSystem fs, Path path) throws IOException { }); try { store.start(16); - ProcedureExecutor pe = new ProcedureExecutor(conf, new Object()/*Pass anything*/, store); + ProcedureExecutor pe = new ProcedureExecutor<>(conf, new Object()/*Pass anything*/, store); pe.init(1, true); } finally { store.stop(true); diff --git a/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureTree.java b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureTree.java new file mode 100644 index 000000000000..6e624b4fca2f --- /dev/null +++ b/hbase-procedure/src/main/java/org/apache/hadoop/hbase/procedure2/store/wal/WALProcedureTree.java @@ -0,0 +1,302 @@ +/** + * 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.procedure2.store.wal; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Collection; +import java.util.Collections; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.NoSuchElementException; +import org.apache.commons.lang3.mutable.MutableInt; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureUtil; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureIterator; +import org.apache.yetus.audience.InterfaceAudience; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; + +/** + * Used to build the tree for procedures. + *

+ * We will group the procedures with the root procedure, and then validate each group. For each + * group of procedures(with the same root procedure), we will collect all the stack ids, if the max + * stack id is n, then all the stack ids should be from 0 to n, non-repetition and non-omission. If + * not, we will consider all the procedures in this group as corrupted. Please see the code in + * {@link #checkReady(Entry, Map)} method. + *

+ * For the procedures not in any group, i.e, can not find the root procedure for these procedures, + * we will also consider them as corrupted. Please see the code in {@link #checkOrphan(Map)} method. + */ +@InterfaceAudience.Private +public final class WALProcedureTree { + + private static final Logger LOG = LoggerFactory.getLogger(WALProcedureTree.class); + + private static final class Entry { + + private final ProcedureProtos.Procedure proc; + + private final List subProcs = new ArrayList<>(); + + public Entry(ProcedureProtos.Procedure proc) { + this.proc = proc; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("Procedure(pid="); + sb.append(proc.getProcId()); + sb.append(", ppid="); + sb.append(proc.hasParentId() ? proc.getParentId() : Procedure.NO_PROC_ID); + sb.append(", class="); + sb.append(proc.getClassName()); + sb.append(")"); + return sb.toString(); + } + } + + // when loading we will iterator the procedures twice, so use this class to cache the deserialized + // result to prevent deserializing multiple times. + private static final class ProtoAndProc { + private final ProcedureProtos.Procedure proto; + + private Procedure proc; + + public ProtoAndProc(ProcedureProtos.Procedure proto) { + this.proto = proto; + } + + public Procedure getProc() throws IOException { + if (proc == null) { + proc = ProcedureUtil.convertToProcedure(proto); + } + return proc; + } + } + + private final List validProcs = new ArrayList<>(); + + private final List corruptedProcs = new ArrayList<>(); + + private static boolean isFinished(ProcedureProtos.Procedure proc) { + if (!proc.hasParentId()) { + switch (proc.getState()) { + case ROLLEDBACK: + case SUCCESS: + return true; + default: + break; + } + } + return false; + } + + private WALProcedureTree(Map procMap) { + List rootEntries = buildTree(procMap); + for (Entry rootEntry : rootEntries) { + checkReady(rootEntry, procMap); + } + checkOrphan(procMap); + Comparator cmp = + (p1, p2) -> Long.compare(p1.proto.getProcId(), p2.proto.getProcId()); + Collections.sort(validProcs, cmp); + Collections.sort(corruptedProcs, cmp); + } + + private List buildTree(Map procMap) { + List rootEntries = new ArrayList<>(); + procMap.values().forEach(entry -> { + if (!entry.proc.hasParentId()) { + rootEntries.add(entry); + } else { + Entry parentEntry = procMap.get(entry.proc.getParentId()); + // For a valid procedure this should not be null. We will log the error later if it is null, + // as it will not be referenced by any root procedures. + if (parentEntry != null) { + parentEntry.subProcs.add(entry); + } + } + }); + return rootEntries; + } + + private void collectStackId(Entry entry, Map> stackId2Proc, + MutableInt maxStackId) { + if (LOG.isDebugEnabled()) { + LOG.debug("Procedure {} stack ids={}", entry, entry.proc.getStackIdList()); + } + for (int i = 0, n = entry.proc.getStackIdCount(); i < n; i++) { + int stackId = entry.proc.getStackId(i); + if (stackId > maxStackId.intValue()) { + maxStackId.setValue(stackId); + } + stackId2Proc.computeIfAbsent(stackId, k -> new ArrayList<>()).add(entry); + } + entry.subProcs.forEach(e -> collectStackId(e, stackId2Proc, maxStackId)); + } + + private void addAllToCorruptedAndRemoveFromProcMap(Entry entry, + Map remainingProcMap) { + corruptedProcs.add(new ProtoAndProc(entry.proc)); + remainingProcMap.remove(entry.proc.getProcId()); + for (Entry e : entry.subProcs) { + addAllToCorruptedAndRemoveFromProcMap(e, remainingProcMap); + } + } + + private void addAllToValidAndRemoveFromProcMap(Entry entry, Map remainingProcMap) { + validProcs.add(new ProtoAndProc(entry.proc)); + remainingProcMap.remove(entry.proc.getProcId()); + for (Entry e : entry.subProcs) { + addAllToValidAndRemoveFromProcMap(e, remainingProcMap); + } + } + + // In this method first we will check whether the given root procedure and all its sub procedures + // are valid, through the procedure stack. And we will also remove all these procedures from the + // remainingProcMap, so at last, if there are still procedures in the map, we know that there are + // orphan procedures. + private void checkReady(Entry rootEntry, Map remainingProcMap) { + if (isFinished(rootEntry.proc)) { + if (!rootEntry.subProcs.isEmpty()) { + LOG.error("unexpected active children for root-procedure: {}", rootEntry); + rootEntry.subProcs.forEach(e -> LOG.error("unexpected active children: {}", e)); + addAllToCorruptedAndRemoveFromProcMap(rootEntry, remainingProcMap); + } else { + addAllToValidAndRemoveFromProcMap(rootEntry, remainingProcMap); + } + return; + } + Map> stackId2Proc = new HashMap<>(); + MutableInt maxStackId = new MutableInt(Integer.MIN_VALUE); + collectStackId(rootEntry, stackId2Proc, maxStackId); + // the stack ids should start from 0 and increase by one every time + boolean valid = true; + for (int i = 0; i <= maxStackId.intValue(); i++) { + List entries = stackId2Proc.get(i); + if (entries == null) { + LOG.error("Missing stack id {}, max stack id is {}, root procedure is {}", i, maxStackId, + rootEntry); + valid = false; + } else if (entries.size() > 1) { + LOG.error("Multiple procedures {} have the same stack id {}, max stack id is {}," + + " root procedure is {}", entries, i, maxStackId, rootEntry); + valid = false; + } + } + if (valid) { + addAllToValidAndRemoveFromProcMap(rootEntry, remainingProcMap); + } else { + addAllToCorruptedAndRemoveFromProcMap(rootEntry, remainingProcMap); + } + } + + private void checkOrphan(Map procMap) { + procMap.values().forEach(entry -> { + LOG.error("Orphan procedure: {}", entry); + corruptedProcs.add(new ProtoAndProc(entry.proc)); + }); + } + + private static final class Iter implements ProcedureIterator { + + private final List procs; + + private Iterator iter; + + private ProtoAndProc current; + + public Iter(List procs) { + this.procs = procs; + reset(); + } + + @Override + public void reset() { + iter = procs.iterator(); + if (iter.hasNext()) { + current = iter.next(); + } else { + current = null; + } + } + + @Override + public boolean hasNext() { + return current != null; + } + + private void checkNext() { + if (!hasNext()) { + throw new NoSuchElementException(); + } + } + + @Override + public boolean isNextFinished() { + checkNext(); + return isFinished(current.proto); + } + + private void moveToNext() { + if (iter.hasNext()) { + current = iter.next(); + } else { + current = null; + } + } + + @Override + public void skipNext() { + checkNext(); + moveToNext(); + } + + @Override + public Procedure next() throws IOException { + checkNext(); + Procedure proc = current.getProc(); + moveToNext(); + return proc; + } + } + + public ProcedureIterator getValidProcs() { + return new Iter(validProcs); + } + + public ProcedureIterator getCorruptedProcs() { + return new Iter(corruptedProcs); + } + + public static WALProcedureTree build(Collection procedures) { + Map procMap = new HashMap<>(); + for (ProcedureProtos.Procedure proc : procedures) { + procMap.put(proc.getProcId(), new Entry(proc)); + } + return new WALProcedureTree(procMap); + } +} diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java index d52b6bb2e5ab..95e032043fb4 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/ProcedureTestingUtility.java @@ -67,20 +67,44 @@ public void recoverFileLease(FileSystem fs, Path path) throws IOException { }); } + public static void restart(final ProcedureExecutor procExecutor, + boolean abort, boolean startWorkers) throws Exception { + restart(procExecutor, false, true, null, null, null, abort, startWorkers); + } + + public static void restart(final ProcedureExecutor procExecutor, + boolean abort) throws Exception { + restart(procExecutor, false, true, null, null, null, abort, true); + } + public static void restart(final ProcedureExecutor procExecutor) throws Exception { - restart(procExecutor, false, true, null, null, null); + restart(procExecutor, false, true, null, null, null, false, true); } public static void initAndStartWorkers(ProcedureExecutor procExecutor, int numThreads, boolean abortOnCorruption) throws IOException { + initAndStartWorkers(procExecutor, numThreads, abortOnCorruption, true); + } + + public static void initAndStartWorkers(ProcedureExecutor procExecutor, int numThreads, + boolean abortOnCorruption, boolean startWorkers) throws IOException { procExecutor.init(numThreads, abortOnCorruption); - procExecutor.startWorkers(); + if (startWorkers) { + procExecutor.startWorkers(); + } } public static void restart(ProcedureExecutor procExecutor, boolean avoidTestKillDuringRestart, boolean failOnCorrupted, Callable stopAction, - Callable actionBeforeStartWorker, Callable startAction) - throws Exception { + Callable actionBeforeStartWorker, Callable startAction) throws Exception { + restart(procExecutor, avoidTestKillDuringRestart, failOnCorrupted, stopAction, + actionBeforeStartWorker, startAction, false, true); + } + + public static void restart(ProcedureExecutor procExecutor, + boolean avoidTestKillDuringRestart, boolean failOnCorrupted, Callable stopAction, + Callable actionBeforeStartWorker, Callable startAction, boolean abort, + boolean startWorkers) throws Exception { final ProcedureStore procStore = procExecutor.getStore(); final int storeThreads = procExecutor.getCorePoolSize(); final int execThreads = procExecutor.getCorePoolSize(); @@ -93,7 +117,7 @@ public static void restart(ProcedureExecutor procExecutor, // stop LOG.info("RESTART - Stop"); procExecutor.stop(); - procStore.stop(false); + procStore.stop(abort); if (stopAction != null) { stopAction.call(); } @@ -109,7 +133,9 @@ public static void restart(ProcedureExecutor procExecutor, if (actionBeforeStartWorker != null) { actionBeforeStartWorker.call(); } - procExecutor.startWorkers(); + if (startWorkers) { + procExecutor.startWorkers(); + } if (startAction != null) { startAction.call(); } @@ -207,7 +233,7 @@ public static long submitAndWait(Configuration conf, TEnv env, Procedure< NoopProcedureStore procStore = new NoopProcedureStore(); ProcedureExecutor procExecutor = new ProcedureExecutor<>(conf, env, procStore); procStore.start(1); - initAndStartWorkers(procExecutor, 1, false); + initAndStartWorkers(procExecutor, 1, false, true); try { return submitAndWait(procExecutor, proc, HConstants.NO_NONCE, HConstants.NO_NONCE); } finally { @@ -400,6 +426,46 @@ protected void deserializeStateData(ProcedureStateSerializer serializer) } } + public static class NoopStateMachineProcedure + extends StateMachineProcedure { + private TState initialState; + private TEnv env; + + public NoopStateMachineProcedure() { + } + + public NoopStateMachineProcedure(TEnv env, TState initialState) { + this.env = env; + this.initialState = initialState; + } + + @Override + protected Flow executeFromState(TEnv env, TState tState) + throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { + return null; + } + + @Override + protected void rollbackState(TEnv env, TState tState) throws IOException, InterruptedException { + + } + + @Override + protected TState getState(int stateId) { + return null; + } + + @Override + protected int getStateId(TState tState) { + return 0; + } + + @Override + protected TState getInitialState() { + return initialState; + } + } + public static class TestProcedure extends NoopProcedure { private byte[] data = null; diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java index d58d57e76e8b..7d587fd0ab51 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureBypass.java @@ -17,8 +17,10 @@ */ package org.apache.hadoop.hbase.procedure2; +import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.stream.Collectors; import org.apache.hadoop.fs.FileSystem; @@ -87,7 +89,7 @@ public void testBypassSuspendProcedure() throws Exception { long id = procExecutor.submitProcedure(proc); Thread.sleep(500); //bypass the procedure - assertTrue(procExecutor.bypassProcedure(id, 30000, false)); + assertTrue(procExecutor.bypassProcedure(id, 30000, false, false)); htu.waitFor(5000, () -> proc.isSuccess() && proc.isBypass()); LOG.info("{} finished", proc); } @@ -98,7 +100,7 @@ public void testStuckProcedure() throws Exception { long id = procExecutor.submitProcedure(proc); Thread.sleep(500); //bypass the procedure - assertTrue(procExecutor.bypassProcedure(id, 1000, true)); + assertTrue(procExecutor.bypassProcedure(id, 1000, true, false)); //Since the procedure is stuck there, we need to restart the executor to recovery. ProcedureTestingUtility.restart(procExecutor); htu.waitFor(5000, () -> proc.isSuccess() && proc.isBypass()); @@ -114,12 +116,38 @@ public void testBypassingProcedureWithParent() throws Exception { .size() > 0); SuspendProcedure suspendProcedure = (SuspendProcedure)procExecutor.getProcedures().stream() .filter(p -> p.getParentProcId() == rootId).collect(Collectors.toList()).get(0); - assertTrue(procExecutor.bypassProcedure(suspendProcedure.getProcId(), 1000, false)); + assertTrue(procExecutor.bypassProcedure(suspendProcedure.getProcId(), 1000, false, false)); htu.waitFor(5000, () -> proc.isSuccess() && proc.isBypass()); LOG.info("{} finished", proc); } + @Test + public void testBypassingStuckStateMachineProcedure() throws Exception { + final StuckStateMachineProcedure proc = + new StuckStateMachineProcedure(procEnv, StuckStateMachineState.START); + long id = procExecutor.submitProcedure(proc); + Thread.sleep(500); + // bypass the procedure + assertFalse(procExecutor.bypassProcedure(id, 1000, false, false)); + assertTrue(procExecutor.bypassProcedure(id, 1000, true, false)); + htu.waitFor(5000, () -> proc.isSuccess() && proc.isBypass()); + LOG.info("{} finished", proc); + } + + @Test + public void testBypassingProcedureWithParentRecursive() throws Exception { + final RootProcedure proc = new RootProcedure(); + long rootId = procExecutor.submitProcedure(proc); + htu.waitFor(5000, () -> procExecutor.getProcedures().stream() + .filter(p -> p.getParentProcId() == rootId).collect(Collectors.toList()) + .size() > 0); + SuspendProcedure suspendProcedure = (SuspendProcedure)procExecutor.getProcedures().stream() + .filter(p -> p.getParentProcId() == rootId).collect(Collectors.toList()).get(0); + assertTrue(procExecutor.bypassProcedure(rootId, 1000, false, true)); + htu.waitFor(5000, () -> proc.isSuccess() && proc.isBypass()); + LOG.info("{} finished", proc); + } @AfterClass public static void tearDown() throws Exception { @@ -181,5 +209,52 @@ protected Procedure[] execute(final TestProcEnv env) } + public enum StuckStateMachineState { + START, THEN, END + } + + public static class StuckStateMachineProcedure extends + ProcedureTestingUtility.NoopStateMachineProcedure { + private AtomicBoolean stop = new AtomicBoolean(false); + + public StuckStateMachineProcedure() { + super(); + } + + public StuckStateMachineProcedure(TestProcEnv env, StuckStateMachineState initialState) { + super(env, initialState); + } + + @Override + protected Flow executeFromState(TestProcEnv env, StuckStateMachineState tState) + throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { + switch (tState) { + case START: + LOG.info("PHASE 1: START"); + setNextState(StuckStateMachineState.THEN); + return Flow.HAS_MORE_STATE; + case THEN: + if (stop.get()) { + setNextState(StuckStateMachineState.END); + } + return Flow.HAS_MORE_STATE; + case END: + return Flow.NO_MORE_STATE; + default: + throw new UnsupportedOperationException("unhandled state=" + tState); + } + } + + @Override + protected StuckStateMachineState getState(int stateId) { + return StuckStateMachineState.values()[stateId]; + } + + @Override + protected int getStateId(StuckStateMachineState tState) { + return tState.ordinal(); + } + } + } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java new file mode 100644 index 000000000000..82917ea5315c --- /dev/null +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureCleanup.java @@ -0,0 +1,286 @@ +/** + * 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.procedure2; + +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.Arrays; +import java.util.concurrent.CountDownLatch; +import java.util.concurrent.Exchanger; +import org.apache.hadoop.fs.FSDataInputStream; +import org.apache.hadoop.fs.FSDataOutputStream; +import org.apache.hadoop.fs.FileStatus; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseCommonTestingUtility; +import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.rules.TestName; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hbase.thirdparty.com.google.common.io.ByteStreams; + +@Category({ MasterTests.class, SmallTests.class }) +public class TestProcedureCleanup { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestProcedureCleanup.class); + + + private static final Logger LOG = LoggerFactory.getLogger(TestProcedureCleanup.class); + + private static final int PROCEDURE_EXECUTOR_SLOTS = 2; + + private static WALProcedureStore procStore; + + private static ProcedureExecutor procExecutor; + + private static HBaseCommonTestingUtility htu; + + private static FileSystem fs; + private static Path testDir; + private static Path logDir; + + @Rule + public final TestName name = new TestName(); + + private void createProcExecutor() throws Exception { + logDir = new Path(testDir, name.getMethodName()); + procStore = ProcedureTestingUtility.createWalStore(htu.getConfiguration(), logDir); + procExecutor = new ProcedureExecutor<>(htu.getConfiguration(), null, procStore); + procStore.start(PROCEDURE_EXECUTOR_SLOTS); + ProcedureTestingUtility.initAndStartWorkers(procExecutor, PROCEDURE_EXECUTOR_SLOTS, true, true); + } + + @BeforeClass + public static void setUp() throws Exception { + htu = new HBaseCommonTestingUtility(); + htu.getConfiguration().setBoolean(WALProcedureStore.EXEC_WAL_CLEANUP_ON_LOAD_CONF_KEY, true); + // NOTE: The executor will be created by each test + testDir = htu.getDataTestDir(); + fs = testDir.getFileSystem(htu.getConfiguration()); + assertTrue(testDir.depth() > 1); + } + + @Test + public void testProcedureShouldNotCleanOnLoad() throws Exception { + createProcExecutor(); + final RootProcedure proc = new RootProcedure(); + long rootProc = procExecutor.submitProcedure(proc); + LOG.info("Begin to execute " + rootProc); + // wait until the child procedure arrival + htu.waitFor(10000, () -> procExecutor.getProcedures().size() >= 2); + SuspendProcedure suspendProcedure = (SuspendProcedure) procExecutor + .getProcedures().get(1); + // wait until the suspendProcedure executed + suspendProcedure.latch.countDown(); + Thread.sleep(100); + // roll the procedure log + LOG.info("Begin to roll log "); + procStore.rollWriterForTesting(); + LOG.info("finish to roll log "); + Thread.sleep(500); + LOG.info("begin to restart1 "); + ProcedureTestingUtility.restart(procExecutor, true); + LOG.info("finish to restart1 "); + assertTrue(procExecutor.getProcedure(rootProc) != null); + Thread.sleep(500); + LOG.info("begin to restart2 "); + ProcedureTestingUtility.restart(procExecutor, true); + LOG.info("finish to restart2 "); + assertTrue(procExecutor.getProcedure(rootProc) != null); + } + + @Test + public void testProcedureUpdatedShouldClean() throws Exception { + createProcExecutor(); + SuspendProcedure suspendProcedure = new SuspendProcedure(); + long suspendProc = procExecutor.submitProcedure(suspendProcedure); + LOG.info("Begin to execute " + suspendProc); + suspendProcedure.latch.countDown(); + Thread.sleep(500); + LOG.info("begin to restart1 "); + ProcedureTestingUtility.restart(procExecutor, true); + LOG.info("finish to restart1 "); + htu.waitFor(10000, () -> procExecutor.getProcedure(suspendProc) != null); + // Wait until the suspendProc executed after restart + suspendProcedure = (SuspendProcedure) procExecutor.getProcedure(suspendProc); + suspendProcedure.latch.countDown(); + Thread.sleep(500); + // Should be 1 log since the suspendProcedure is updated in the new log + assertTrue(procStore.getActiveLogs().size() == 1); + // restart procExecutor + LOG.info("begin to restart2"); + // Restart the executor but do not start the workers. + // Otherwise, the suspendProcedure will soon be executed and the oldest log + // will be cleaned, leaving only the newest log. + ProcedureTestingUtility.restart(procExecutor, true, false); + LOG.info("finish to restart2"); + // There should be two active logs + assertTrue(procStore.getActiveLogs().size() == 2); + procExecutor.startWorkers(); + + } + + @Test + public void testProcedureDeletedShouldClean() throws Exception { + createProcExecutor(); + WaitProcedure waitProcedure = new WaitProcedure(); + long waitProce = procExecutor.submitProcedure(waitProcedure); + LOG.info("Begin to execute " + waitProce); + Thread.sleep(500); + LOG.info("begin to restart1 "); + ProcedureTestingUtility.restart(procExecutor, true); + LOG.info("finish to restart1 "); + htu.waitFor(10000, () -> procExecutor.getProcedure(waitProce) != null); + // Wait until the suspendProc executed after restart + waitProcedure = (WaitProcedure) procExecutor.getProcedure(waitProce); + waitProcedure.latch.countDown(); + Thread.sleep(500); + // Should be 1 log since the suspendProcedure is updated in the new log + assertTrue(procStore.getActiveLogs().size() == 1); + // restart procExecutor + LOG.info("begin to restart2"); + // Restart the executor but do not start the workers. + // Otherwise, the suspendProcedure will soon be executed and the oldest log + // will be cleaned, leaving only the newest log. + ProcedureTestingUtility.restart(procExecutor, true, false); + LOG.info("finish to restart2"); + // There should be two active logs + assertTrue(procStore.getActiveLogs().size() == 2); + procExecutor.startWorkers(); + } + + private void corrupt(FileStatus file) throws IOException { + LOG.info("Corrupt " + file); + Path tmpFile = file.getPath().suffix(".tmp"); + // remove the last byte to make the trailer corrupted + try (FSDataInputStream in = fs.open(file.getPath()); + FSDataOutputStream out = fs.create(tmpFile)) { + ByteStreams.copy(ByteStreams.limit(in, file.getLen() - 1), out); + } + fs.delete(file.getPath(), false); + fs.rename(tmpFile, file.getPath()); + } + + + public static final class ExchangeProcedure extends ProcedureTestingUtility.NoopProcedure { + + private final Exchanger exchanger = new Exchanger<>(); + + @SuppressWarnings("unchecked") + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + if (exchanger.exchange(Boolean.TRUE)) { + return new Procedure[] { this }; + } else { + return null; + } + } + } + + @Test + public void testResetDeleteWhenBuildingHoldingCleanupTracker() throws Exception { + createProcExecutor(); + ExchangeProcedure proc1 = new ExchangeProcedure(); + ExchangeProcedure proc2 = new ExchangeProcedure(); + procExecutor.submitProcedure(proc1); + long procId2 = procExecutor.submitProcedure(proc2); + Thread.sleep(500); + procStore.rollWriterForTesting(); + proc1.exchanger.exchange(Boolean.TRUE); + Thread.sleep(500); + + FileStatus[] walFiles = fs.listStatus(logDir); + Arrays.sort(walFiles, (f1, f2) -> f1.getPath().getName().compareTo(f2.getPath().getName())); + // corrupt the first proc wal file, so we will have a partial tracker for it after restarting + corrupt(walFiles[0]); + ProcedureTestingUtility.restart(procExecutor, false, true); + // also update proc2, which means that all the procedures in the first proc wal have been + // updated and it should be deleted. + proc2 = (ExchangeProcedure) procExecutor.getProcedure(procId2); + proc2.exchanger.exchange(Boolean.TRUE); + htu.waitFor(10000, () -> !fs.exists(walFiles[0].getPath())); + } + + public static class WaitProcedure extends ProcedureTestingUtility.NoopProcedure { + public WaitProcedure() { + super(); + } + + private CountDownLatch latch = new CountDownLatch(1); + + @Override + protected Procedure[] execute(Void env) throws ProcedureSuspendedException { + // Always wait here + LOG.info("wait here"); + try { + latch.await(); + } catch (Throwable t) { + + } + LOG.info("finished"); + return null; + } + } + + public static class SuspendProcedure extends ProcedureTestingUtility.NoopProcedure { + public SuspendProcedure() { + super(); + } + + private CountDownLatch latch = new CountDownLatch(1); + + @Override + protected Procedure[] execute(Void env) throws ProcedureSuspendedException { + // Always suspend the procedure + LOG.info("suspend here"); + latch.countDown(); + throw new ProcedureSuspendedException(); + } + } + + public static class RootProcedure extends ProcedureTestingUtility.NoopProcedure { + private boolean childSpwaned = false; + + public RootProcedure() { + super(); + } + + @Override + protected Procedure[] execute(Void env) throws ProcedureSuspendedException { + if (!childSpwaned) { + childSpwaned = true; + return new Procedure[] { new SuspendProcedure() }; + } else { + return null; + } + } + } +} diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java index a3cff582fd9f..e734bcb93d4b 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureExecution.java @@ -52,7 +52,7 @@ public class TestProcedureExecution { private static final Logger LOG = LoggerFactory.getLogger(TestProcedureExecution.class); private static final int PROCEDURE_EXECUTOR_SLOTS = 1; - private static final Procedure NULL_PROC = null; + private static final Procedure NULL_PROC = null; private ProcedureExecutor procExecutor; private ProcedureStore procStore; @@ -84,11 +84,16 @@ public void tearDown() throws IOException { } private static class TestProcedureException extends IOException { - public TestProcedureException(String msg) { super(msg); } + + private static final long serialVersionUID = 8798565784658913798L; + + public TestProcedureException(String msg) { + super(msg); + } } public static class TestSequentialProcedure extends SequentialProcedure { - private final Procedure[] subProcs; + private final Procedure[] subProcs; private final List state; private final Exception failure; private final String name; @@ -112,7 +117,7 @@ public TestSequentialProcedure(String name, List state, Exception failur } @Override - protected Procedure[] execute(Void env) { + protected Procedure[] execute(Void env) { state.add(name + "-execute"); if (failure != null) { setFailure(new RemoteProcedureException(name + "-failure", failure)); @@ -136,9 +141,9 @@ protected boolean abort(Void env) { @Test public void testBadSubprocList() { List state = new ArrayList<>(); - Procedure subProc2 = new TestSequentialProcedure("subProc2", state); - Procedure subProc1 = new TestSequentialProcedure("subProc1", state, subProc2, NULL_PROC); - Procedure rootProc = new TestSequentialProcedure("rootProc", state, subProc1); + Procedure subProc2 = new TestSequentialProcedure("subProc2", state); + Procedure subProc1 = new TestSequentialProcedure("subProc1", state, subProc2, NULL_PROC); + Procedure rootProc = new TestSequentialProcedure("rootProc", state, subProc1); long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, rootProc); // subProc1 has a "null" subprocedure which is catched as InvalidArgument @@ -158,9 +163,9 @@ public void testBadSubprocList() { @Test public void testSingleSequentialProc() { List state = new ArrayList<>(); - Procedure subProc2 = new TestSequentialProcedure("subProc2", state); - Procedure subProc1 = new TestSequentialProcedure("subProc1", state, subProc2); - Procedure rootProc = new TestSequentialProcedure("rootProc", state, subProc1); + Procedure subProc2 = new TestSequentialProcedure("subProc2", state); + Procedure subProc1 = new TestSequentialProcedure("subProc1", state, subProc2); + Procedure rootProc = new TestSequentialProcedure("rootProc", state, subProc1); long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, rootProc); // successful state, with 3 execute @@ -173,10 +178,10 @@ public void testSingleSequentialProc() { @Test public void testSingleSequentialProcRollback() { List state = new ArrayList<>(); - Procedure subProc2 = new TestSequentialProcedure("subProc2", state, - new TestProcedureException("fail test")); - Procedure subProc1 = new TestSequentialProcedure("subProc1", state, subProc2); - Procedure rootProc = new TestSequentialProcedure("rootProc", state, subProc1); + Procedure subProc2 = + new TestSequentialProcedure("subProc2", state, new TestProcedureException("fail test")); + Procedure subProc1 = new TestSequentialProcedure("subProc1", state, subProc2); + Procedure rootProc = new TestSequentialProcedure("rootProc", state, subProc1); long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, rootProc); // the 3rd proc fail, rollback after 2 successful execution @@ -203,7 +208,7 @@ public static class TestFaultyRollback extends SequentialProcedure { public TestFaultyRollback() { } @Override - protected Procedure[] execute(Void env) { + protected Procedure[] execute(Void env) { setFailure("faulty-rollback-test", new TestProcedureException("test faulty rollback")); return null; } @@ -249,7 +254,7 @@ public TestWaitingProcedure(String name, List state, boolean hasChild) { } @Override - protected Procedure[] execute(Void env) { + protected Procedure[] execute(Void env) { state.add(name + "-execute"); setState(ProcedureState.WAITING_TIMEOUT); return hasChild ? new Procedure[] { new TestWaitChild(name, state) } : null; @@ -280,14 +285,14 @@ public TestWaitChild(String name, List state) { } @Override - protected Procedure[] execute(Void env) { + protected Procedure[] execute(Void env) { state.add(name + "-child-execute"); return null; } @Override protected void rollback(Void env) { - state.add(name + "-child-rollback"); + throw new UnsupportedOperationException("should not rollback a successful child procedure"); } @Override @@ -302,7 +307,7 @@ protected boolean abort(Void env) { public void testAbortTimeout() { final int PROC_TIMEOUT_MSEC = 2500; List state = new ArrayList<>(); - Procedure proc = new TestWaitingProcedure("wproc", state, false); + Procedure proc = new TestWaitingProcedure("wproc", state, false); proc.setTimeout(PROC_TIMEOUT_MSEC); long startTime = EnvironmentEdgeManager.currentTime(); long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, proc); @@ -320,17 +325,16 @@ public void testAbortTimeout() { @Test public void testAbortTimeoutWithChildren() { List state = new ArrayList<>(); - Procedure proc = new TestWaitingProcedure("wproc", state, true); + Procedure proc = new TestWaitingProcedure("wproc", state, true); proc.setTimeout(2500); long rootId = ProcedureTestingUtility.submitAndWait(procExecutor, proc); LOG.info(Objects.toString(state)); Procedure result = procExecutor.getResult(rootId); assertTrue(state.toString(), result.isFailed()); ProcedureTestingUtility.assertIsTimeoutException(result); - assertEquals(state.toString(), 4, state.size()); + assertEquals(state.toString(), 3, state.size()); assertEquals("wproc-execute", state.get(0)); assertEquals("wproc-child-execute", state.get(1)); - assertEquals("wproc-child-rollback", state.get(2)); - assertEquals("wproc-rollback", state.get(3)); + assertEquals("wproc-rollback", state.get(2)); } } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java new file mode 100644 index 000000000000..fc12924244e1 --- /dev/null +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureRollbackAIOOB.java @@ -0,0 +1,117 @@ +/** + * 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.procedure2; + +import java.io.IOException; +import java.util.concurrent.CountDownLatch; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseCommonTestingUtility; +import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.NoopProcedure; +import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.rules.TestName; + +/** + * Testcase for HBASE-20973 + */ +@Category({ MasterTests.class, MediumTests.class }) +public class TestProcedureRollbackAIOOB { + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestProcedureRollbackAIOOB.class); + + private static final HBaseCommonTestingUtility UTIL = new HBaseCommonTestingUtility(); + + public static final class ParentProcedure extends NoopProcedure { + + private final CountDownLatch latch = new CountDownLatch(1); + + private boolean scheduled; + + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + latch.await(); + if (scheduled) { + return null; + } + scheduled = true; + return new Procedure[] { new SubProcedure() }; + } + } + + public static final class SubProcedure extends NoopProcedure { + + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + setFailure("Inject error", new RuntimeException("Inject error")); + return null; + } + } + + private WALProcedureStore procStore; + + private ProcedureExecutor procExec; + + @Rule + public final TestName name = new TestName(); + + @Before + public void setUp() throws IOException { + procStore = ProcedureTestingUtility.createWalStore(UTIL.getConfiguration(), + UTIL.getDataTestDir(name.getMethodName())); + procStore.start(2); + procExec = new ProcedureExecutor(UTIL.getConfiguration(), null, procStore); + ProcedureTestingUtility.initAndStartWorkers(procExec, 2, true); + } + + @After + public void tearDown() { + procExec.stop(); + procStore.stop(false); + } + + @AfterClass + public static void tearDownAfterClass() throws IOException { + UTIL.cleanupTestDir(); + } + + @Test + public void testArrayIndexOutOfBounds() { + ParentProcedure proc = new ParentProcedure(); + long procId = procExec.submitProcedure(proc); + long noopProcId = -1L; + // make sure that the sub procedure will have a new BitSetNode + for (int i = 0; i < Long.SIZE - 2; i++) { + noopProcId = procExec.submitProcedure(new NoopProcedure<>()); + } + final long lastNoopProcId = noopProcId; + UTIL.waitFor(30000, () -> procExec.isFinished(lastNoopProcId)); + proc.latch.countDown(); + UTIL.waitFor(10000, () -> procExec.isFinished(procId)); + } +} diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java new file mode 100644 index 000000000000..8293dcb4ed34 --- /dev/null +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureSkipPersistence.java @@ -0,0 +1,163 @@ +/** + * 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.procedure2; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseCommonTestingUtility; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.junit.After; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; + +@Category({ MasterTests.class, MediumTests.class }) +public class TestProcedureSkipPersistence { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestProcedureSkipPersistence.class); + private ProcedureExecutor procExecutor; + private ProcedureStore procStore; + + private HBaseCommonTestingUtility htu; + private FileSystem fs; + private Path testDir; + private Path logDir; + + private static volatile int STEP = 0; + + public class ProcEnv { + + public ProcedureExecutor getProcedureExecutor() { + return procExecutor; + } + } + + public static class TestProcedure extends Procedure { + + // need to override this method, otherwise we will persist the release lock operation and the + // test will fail. + @Override + protected boolean holdLock(ProcEnv env) { + return true; + } + + @Override + protected Procedure[] execute(ProcEnv env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + if (STEP == 0) { + STEP = 1; + setTimeout(60 * 60 * 1000); + setState(ProcedureProtos.ProcedureState.WAITING_TIMEOUT); + skipPersistence(); + throw new ProcedureSuspendedException(); + } else if (STEP == 1) { + STEP = 2; + if (hasTimeout()) { + setFailure("Should not persist the timeout value", + new IOException("Should not persist the timeout value")); + return null; + } + setTimeout(2 * 1000); + setState(ProcedureProtos.ProcedureState.WAITING_TIMEOUT); + // used to confirm that we reset the persist flag before execution + throw new ProcedureSuspendedException(); + } else { + if (!hasTimeout()) { + setFailure("Should have persisted the timeout value", + new IOException("Should have persisted the timeout value")); + } + return null; + } + } + + @Override + protected synchronized boolean setTimeoutFailure(ProcEnv env) { + setState(ProcedureProtos.ProcedureState.RUNNABLE); + env.getProcedureExecutor().getProcedureScheduler().addFront(this); + return false; + } + + @Override + protected void rollback(ProcEnv env) throws IOException, InterruptedException { + throw new UnsupportedOperationException(); + } + + @Override + protected boolean abort(ProcEnv env) { + return false; + } + + @Override + protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + + @Override + protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + } + + @Before + public void setUp() throws IOException { + htu = new HBaseCommonTestingUtility(); + testDir = htu.getDataTestDir(); + fs = testDir.getFileSystem(htu.getConfiguration()); + assertTrue(testDir.depth() > 1); + + logDir = new Path(testDir, "proc-logs"); + procStore = ProcedureTestingUtility.createWalStore(htu.getConfiguration(), logDir); + procExecutor = new ProcedureExecutor<>(htu.getConfiguration(), new ProcEnv(), procStore); + procStore.start(1); + ProcedureTestingUtility.initAndStartWorkers(procExecutor, 1, true); + } + + @After + public void tearDown() throws IOException { + procExecutor.stop(); + procStore.stop(false); + fs.delete(logDir, true); + } + + @Test + public void test() throws Exception { + TestProcedure proc = new TestProcedure(); + long procId = procExecutor.submitProcedure(proc); + htu.waitFor(30000, () -> proc.isWaiting()); + ProcedureTestingUtility.restart(procExecutor); + htu.waitFor(30000, () -> { + Procedure p = procExecutor.getProcedure(procId); + return p.isWaiting() || p.isFinished(); + }); + assertFalse(procExecutor.isFinished(procId)); + ProcedureTestingUtility.restart(procExecutor); + htu.waitFor(30000, () -> procExecutor.isFinished(procId)); + Procedure p = procExecutor.getResult(procId); + assertTrue(p.isSuccess()); + } +} diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java index 6342beccae01..3629fb74bc6c 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestProcedureUtil.java @@ -18,6 +18,7 @@ package org.apache.hadoop.hbase.procedure2; import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; import java.util.concurrent.TimeUnit; import org.apache.hadoop.hbase.HBaseClassTestRule; @@ -63,9 +64,17 @@ public void testGetBackoffTimeMs() { for (int i = 30; i < 1000; i++) { assertEquals(TimeUnit.MINUTES.toMillis(10), ProcedureUtil.getBackoffTimeMs(30)); } - assertEquals(1000, ProcedureUtil.getBackoffTimeMs(0)); - assertEquals(2000, ProcedureUtil.getBackoffTimeMs(1)); - assertEquals(32000, ProcedureUtil.getBackoffTimeMs(5)); + long backoffTimeMs = ProcedureUtil.getBackoffTimeMs(0); + assertTrue(backoffTimeMs >= 1000); + assertTrue(backoffTimeMs <= 1000 * 1.01f); + + backoffTimeMs = ProcedureUtil.getBackoffTimeMs(1); + assertTrue(backoffTimeMs >= 2000); + assertTrue(backoffTimeMs <= 2000 * 1.01f); + + backoffTimeMs = ProcedureUtil.getBackoffTimeMs(5); + assertTrue(backoffTimeMs >= 32000); + assertTrue(backoffTimeMs <= 32000 * 1.01f); } public static class TestProcedureNoDefaultConstructor extends TestProcedure { diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java index b1ed5fbff0be..a2c385705a66 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/TestStateMachineProcedure.java @@ -48,6 +48,9 @@ public class TestStateMachineProcedure { private static final Logger LOG = LoggerFactory.getLogger(TestStateMachineProcedure.class); private static final Exception TEST_FAILURE_EXCEPTION = new Exception("test failure") { + + private static final long serialVersionUID = 2147942238987041310L; + @Override public boolean equals(final Object other) { if (this == other) return true; @@ -192,6 +195,11 @@ protected Flow executeFromState(TestProcEnv env, TestSMProcedureState state) { return Flow.HAS_MORE_STATE; } + @Override + protected boolean isRollbackSupported(TestSMProcedureState state) { + return true; + } + @Override protected void rollbackState(TestProcEnv env, TestSMProcedureState state) { LOG.info("ROLLBACK " + state + " " + this); @@ -274,7 +282,7 @@ protected void rollback(final TestProcEnv env) public static class SimpleChildProcedure extends NoopProcedure { @Override - protected Procedure[] execute(TestProcEnv env) { + protected Procedure[] execute(TestProcEnv env) { LOG.info("EXEC " + this); env.execCount.incrementAndGet(); if (env.triggerChildRollback) { diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestBitSetNode.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestBitSetNode.java new file mode 100644 index 000000000000..8d193d029b4c --- /dev/null +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestBitSetNode.java @@ -0,0 +1,59 @@ +/** + * 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.procedure2.store; + +import static org.junit.Assert.assertEquals; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({ MasterTests.class, SmallTests.class }) +public class TestBitSetNode { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestBitSetNode.class); + + @Test + public void testGetActiveMaxMinProcId() { + BitSetNode node = new BitSetNode(5L, false); + assertEquals(5L, node.getActiveMinProcId()); + assertEquals(5L, node.getActiveMaxProcId()); + node.insertOrUpdate(10L); + assertEquals(5L, node.getActiveMinProcId()); + assertEquals(10L, node.getActiveMaxProcId()); + node.insertOrUpdate(1L); + assertEquals(1L, node.getActiveMinProcId()); + assertEquals(10L, node.getActiveMaxProcId()); + + node.delete(10L); + assertEquals(1L, node.getActiveMinProcId()); + assertEquals(5L, node.getActiveMaxProcId()); + node.delete(1L); + assertEquals(5L, node.getActiveMinProcId()); + assertEquals(5L, node.getActiveMaxProcId()); + node.delete(5L); + assertEquals(Procedure.NO_PROC_ID, node.getActiveMinProcId()); + assertEquals(Procedure.NO_PROC_ID, node.getActiveMaxProcId()); + } +} diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureStoreTracker.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureStoreTracker.java index ffc6ab8de0da..ab448be89734 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureStoreTracker.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/TestProcedureStoreTracker.java @@ -23,7 +23,7 @@ import java.util.Random; import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker.BitSetNode; +import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.junit.ClassRule; @@ -119,29 +119,29 @@ public void testBasicCRUD() { tracker.insert(procs[0]); tracker.insert(procs[1], new long[] { procs[2], procs[3], procs[4] }); assertFalse(tracker.isEmpty()); - assertTrue(tracker.isUpdated()); + assertTrue(tracker.isAllModified()); - tracker.resetUpdates(); - assertFalse(tracker.isUpdated()); + tracker.resetModified(); + assertFalse(tracker.isAllModified()); for (int i = 0; i < 4; ++i) { tracker.update(procs[i]); assertFalse(tracker.isEmpty()); - assertFalse(tracker.isUpdated()); + assertFalse(tracker.isAllModified()); } tracker.update(procs[4]); assertFalse(tracker.isEmpty()); - assertTrue(tracker.isUpdated()); + assertTrue(tracker.isAllModified()); tracker.update(procs[5]); assertFalse(tracker.isEmpty()); - assertTrue(tracker.isUpdated()); + assertTrue(tracker.isAllModified()); for (int i = 0; i < 5; ++i) { tracker.delete(procs[i]); assertFalse(tracker.isEmpty()); - assertTrue(tracker.isUpdated()); + assertTrue(tracker.isAllModified()); } tracker.delete(procs[5]); assertTrue(tracker.isEmpty()); @@ -218,54 +218,8 @@ public void testDelete() { } } - boolean isDeleted(ProcedureStoreTracker n, long procId) { - return n.isDeleted(procId) == ProcedureStoreTracker.DeleteState.YES; - } - - boolean isDeleted(BitSetNode n, long procId) { - return n.isDeleted(procId) == ProcedureStoreTracker.DeleteState.YES; - } - - /** - * @param active list of active proc ids. To mark them as non-deleted, since by default a proc - * id is always marked deleted. - */ - ProcedureStoreTracker buildTracker(long[] active, long[] updated, long[] deleted) { - ProcedureStoreTracker tracker = new ProcedureStoreTracker(); - for (long i : active) { - tracker.insert(i); - } - tracker.resetUpdates(); - for (long i : updated) { - tracker.update(i); - } - for (long i : deleted) { - tracker.delete(i); - } - return tracker; - } - - /** - * @param active list of active proc ids. To mark them as non-deleted, since by default a proc - * id is always marked deleted. - */ - BitSetNode buildBitSetNode(long[] active, long[] updated, long[] deleted) { - BitSetNode bitSetNode = new BitSetNode(0L, false); - for (long i : active) { - bitSetNode.update(i); - } - bitSetNode.resetUpdates(); - for (long i : updated) { - bitSetNode.update(i); - } - for (long i : deleted) { - bitSetNode.delete(i); - } - return bitSetNode; - } - @Test - public void testSetDeletedIfSet() { + public void testSetDeletedIfModified() { final ProcedureStoreTracker tracker = new ProcedureStoreTracker(); final long[] procIds = new long[] { 1, 3, 7, 152, 512, 1024, 1025 }; @@ -276,9 +230,9 @@ public void testSetDeletedIfSet() { assertEquals(false, tracker.isEmpty()); for (int i = 0; i < procIds.length; ++i) { - tracker.setDeletedIfSet(procIds[i] - 1); - tracker.setDeletedIfSet(procIds[i]); - tracker.setDeletedIfSet(procIds[i] + 1); + tracker.setDeletedIfModified(procIds[i] - 1); + tracker.setDeletedIfModified(procIds[i]); + tracker.setDeletedIfModified(procIds[i] + 1); } assertEquals(true, tracker.isEmpty()); @@ -289,7 +243,37 @@ public void testSetDeletedIfSet() { } assertEquals(false, tracker.isEmpty()); - tracker.setDeletedIfSet(procIds); + tracker.setDeletedIfModified(procIds); assertEquals(true, tracker.isEmpty()); } + + @Test + public void testGetActiveProcIds() { + ProcedureStoreTracker tracker = new ProcedureStoreTracker(); + for (int i = 0; i < 10000; i++) { + tracker.insert(i * 10); + } + for (int i = 0; i < 10000; i += 2) { + tracker.delete(i * 10); + } + long[] activeProcIds = tracker.getAllActiveProcIds(); + assertEquals(5000, activeProcIds.length); + for (int i = 0; i < 5000; i++) { + assertEquals((2 * i + 1) * 10, activeProcIds[i]); + } + } + + @Test + public void testGetActiveMinProcId() { + ProcedureStoreTracker tracker = new ProcedureStoreTracker(); + assertEquals(Procedure.NO_PROC_ID, tracker.getActiveMinProcId()); + for (int i = 100; i < 1000; i = 2 * i + 1) { + tracker.insert(i); + } + for (int i = 100; i < 1000; i = 2 * i + 1) { + assertEquals(i, tracker.getActiveMinProcId()); + tracker.delete(i); + } + assertEquals(Procedure.NO_PROC_ID, tracker.getActiveMinProcId()); + } } diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestForceUpdateProcedure.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestForceUpdateProcedure.java new file mode 100644 index 000000000000..df6ee51efe3f --- /dev/null +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestForceUpdateProcedure.java @@ -0,0 +1,246 @@ +/** + * 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.procedure2.store.wal; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.Exchanger; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseCommonTestingUtility; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; +import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; +import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; +import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; +import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos.ProcedureState; + +@Category({ MasterTests.class, SmallTests.class }) +public class TestForceUpdateProcedure { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestForceUpdateProcedure.class); + + private static HBaseCommonTestingUtility UTIL = new HBaseCommonTestingUtility(); + + private static WALProcedureStore STORE; + + private static ProcedureExecutor EXEC; + + private static Exchanger EXCHANGER = new Exchanger<>(); + + private static int WAL_COUNT = 5; + + private static void createStoreAndExecutor() throws IOException { + Path logDir = UTIL.getDataTestDir("proc-wals"); + STORE = ProcedureTestingUtility.createWalStore(UTIL.getConfiguration(), logDir); + STORE.start(1); + EXEC = new ProcedureExecutor(UTIL.getConfiguration(), null, STORE); + ProcedureTestingUtility.initAndStartWorkers(EXEC, 1, true); + } + + @BeforeClass + public static void setUp() throws IOException { + UTIL.getConfiguration().setInt(WALProcedureStore.WAL_COUNT_WARN_THRESHOLD_CONF_KEY, WAL_COUNT); + createStoreAndExecutor(); + } + + private static void stopStoreAndExecutor() { + EXEC.stop(); + STORE.stop(false); + EXEC = null; + STORE = null; + } + + @AfterClass + public static void tearDown() throws IOException { + stopStoreAndExecutor(); + UTIL.cleanupTestDir(); + } + + public static final class WaitingProcedure extends Procedure { + + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + EXCHANGER.exchange(Boolean.TRUE); + setState(ProcedureState.WAITING_TIMEOUT); + setTimeout(Integer.MAX_VALUE); + throw new ProcedureSuspendedException(); + } + + @Override + protected void rollback(Void env) throws IOException, InterruptedException { + throw new UnsupportedOperationException(); + } + + @Override + protected boolean abort(Void env) { + return false; + } + + @Override + protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + + @Override + protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + } + + public static final class ParentProcedure extends Procedure { + + @SuppressWarnings("unchecked") + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + return new Procedure[] { new DummyProcedure(), new WaitingProcedure() }; + } + + @Override + protected void rollback(Void env) throws IOException, InterruptedException { + throw new UnsupportedOperationException(); + } + + @Override + protected boolean abort(Void env) { + return false; + } + + @Override + protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + + @Override + protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + } + + public static final class DummyProcedure extends Procedure { + + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + return null; + } + + @Override + protected void rollback(Void env) throws IOException, InterruptedException { + throw new UnsupportedOperationException(); + } + + @Override + protected boolean abort(Void env) { + return false; + } + + @Override + protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + + @Override + protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + } + + public static final class ExchangeProcedure extends Procedure { + + @SuppressWarnings("unchecked") + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + if (EXCHANGER.exchange(Boolean.TRUE)) { + return new Procedure[] { this }; + } else { + return null; + } + } + + @Override + protected void rollback(Void env) throws IOException, InterruptedException { + throw new UnsupportedOperationException(); + } + + @Override + protected boolean abort(Void env) { + return false; + } + + @Override + protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + + @Override + protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + } + + @Test + public void test() throws IOException, InterruptedException { + EXEC.submitProcedure(new ParentProcedure()); + EXCHANGER.exchange(Boolean.TRUE); + UTIL.waitFor(10000, () -> EXEC.getActiveExecutorCount() == 0); + // The above operations are used to make sure that we have persist the states of the two + // procedures. + long procId = EXEC.submitProcedure(new ExchangeProcedure()); + assertEquals(1, STORE.getActiveLogs().size()); + for (int i = 0; i < WAL_COUNT - 1; i++) { + assertTrue(STORE.rollWriterForTesting()); + // The WaitinProcedure never gets updated so we can not delete the oldest wal file, so the + // number of wal files will increase + assertEquals(2 + i, STORE.getActiveLogs().size()); + EXCHANGER.exchange(Boolean.TRUE); + Thread.sleep(1000); + } + STORE.rollWriterForTesting(); + // Finish the ExchangeProcedure + EXCHANGER.exchange(Boolean.FALSE); + // Make sure that we can delete several wal files because we force update the state of + // WaitingProcedure. Notice that the last closed wal files can not be deleted, as when rolling + // the newest wal file does not have anything in it, and in the closed file we still have the + // state for the ExchangeProcedure so it can not be deleted + UTIL.waitFor(10000, () -> STORE.getActiveLogs().size() <= 2); + UTIL.waitFor(10000, () -> EXEC.isFinished(procId)); + // Make sure that after the force update we could still load the procedures + stopStoreAndExecutor(); + createStoreAndExecutor(); + Map, Procedure> procMap = new HashMap<>(); + EXEC.getActiveProceduresNoCopy().forEach(p -> procMap.put(p.getClass(), p)); + assertEquals(3, procMap.size()); + ParentProcedure parentProc = (ParentProcedure) procMap.get(ParentProcedure.class); + assertEquals(ProcedureState.WAITING, parentProc.getState()); + WaitingProcedure waitingProc = (WaitingProcedure) procMap.get(WaitingProcedure.class); + assertEquals(ProcedureState.WAITING_TIMEOUT, waitingProc.getState()); + DummyProcedure dummyProc = (DummyProcedure) procMap.get(DummyProcedure.class); + assertEquals(ProcedureState.SUCCESS, dummyProc.getState()); + } +} diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java index 443386d0845f..da53fa5d0bb7 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestStressWALProcedureStore.java @@ -18,9 +18,7 @@ package org.apache.hadoop.hbase.procedure2.store.wal; import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; import java.io.IOException; import java.util.Random; diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java index b1bd254b8006..0f598b0df8ea 100644 --- a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureStore.java @@ -20,7 +20,6 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; import java.io.FileNotFoundException; import java.io.IOException; @@ -44,7 +43,6 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility.TestProcedure; import org.apache.hadoop.hbase.procedure2.SequentialProcedure; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; -import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureIterator; import org.apache.hadoop.hbase.procedure2.store.ProcedureStoreTracker; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; @@ -72,7 +70,6 @@ public class TestWALProcedureStore { private static final Logger LOG = LoggerFactory.getLogger(TestWALProcedureStore.class); private static final int PROCEDURE_STORE_SLOTS = 1; - private static final Procedure NULL_PROC = null; private WALProcedureStore procStore; @@ -153,7 +150,7 @@ public void trackersLoadedForAllOldLogs() throws Exception { @Test public void testWalCleanerSequentialClean() throws Exception { - final Procedure[] procs = new Procedure[5]; + final Procedure[] procs = new Procedure[5]; ArrayList logs = null; // Insert procedures and roll wal after every insert. @@ -182,7 +179,7 @@ public void testWalCleanerSequentialClean() throws Exception { // they are in the starting of the list. @Test public void testWalCleanerNoHoles() throws Exception { - final Procedure[] procs = new Procedure[5]; + final Procedure[] procs = new Procedure[5]; ArrayList logs = null; // Insert procedures and roll wal after every insert. for (int i = 0; i < procs.length; i++) { @@ -242,7 +239,7 @@ public void testWalCleanerUpdatesDontLeaveHoles() throws Exception { @Test public void testWalCleanerWithEmptyRolls() throws Exception { - final Procedure[] procs = new Procedure[3]; + final Procedure[] procs = new Procedure[3]; for (int i = 0; i < procs.length; ++i) { procs[i] = new TestSequentialProcedure(); procStore.insert(procs[i], null); @@ -284,12 +281,12 @@ public void testLoad() throws Exception { Set procIds = new HashSet<>(); // Insert something in the log - Procedure proc1 = new TestSequentialProcedure(); + Procedure proc1 = new TestSequentialProcedure(); procIds.add(proc1.getProcId()); procStore.insert(proc1, null); - Procedure proc2 = new TestSequentialProcedure(); - Procedure[] child2 = new Procedure[2]; + Procedure proc2 = new TestSequentialProcedure(); + Procedure[] child2 = new Procedure[2]; child2[0] = new TestSequentialProcedure(); child2[1] = new TestSequentialProcedure(); @@ -323,11 +320,11 @@ public void testLoad() throws Exception { @Test public void testNoTrailerDoubleRestart() throws Exception { // log-0001: proc 0, 1 and 2 are inserted - Procedure proc0 = new TestSequentialProcedure(); + Procedure proc0 = new TestSequentialProcedure(); procStore.insert(proc0, null); - Procedure proc1 = new TestSequentialProcedure(); + Procedure proc1 = new TestSequentialProcedure(); procStore.insert(proc1, null); - Procedure proc2 = new TestSequentialProcedure(); + Procedure proc2 = new TestSequentialProcedure(); procStore.insert(proc2, null); procStore.rollWriterForTesting(); @@ -420,19 +417,19 @@ public void testCorruptedTrailer() throws Exception { } private static void assertUpdated(final ProcedureStoreTracker tracker, - final Procedure[] procs, final int[] updatedProcs, final int[] nonUpdatedProcs) { + final Procedure[] procs, final int[] updatedProcs, final int[] nonUpdatedProcs) { for (int index : updatedProcs) { long procId = procs[index].getProcId(); - assertTrue("Procedure id : " + procId, tracker.isUpdated(procId)); + assertTrue("Procedure id : " + procId, tracker.isModified(procId)); } for (int index : nonUpdatedProcs) { long procId = procs[index].getProcId(); - assertFalse("Procedure id : " + procId, tracker.isUpdated(procId)); + assertFalse("Procedure id : " + procId, tracker.isModified(procId)); } } private static void assertDeleted(final ProcedureStoreTracker tracker, - final Procedure[] procs, final int[] deletedProcs, final int[] nonDeletedProcs) { + final Procedure[] procs, final int[] deletedProcs, final int[] nonDeletedProcs) { for (int index : deletedProcs) { long procId = procs[index].getProcId(); assertEquals("Procedure id : " + procId, @@ -447,7 +444,7 @@ private static void assertDeleted(final ProcedureStoreTracker tracker, @Test public void testCorruptedTrailersRebuild() throws Exception { - final Procedure[] procs = new Procedure[6]; + final Procedure[] procs = new Procedure[6]; for (int i = 0; i < procs.length; ++i) { procs[i] = new TestSequentialProcedure(); } @@ -575,127 +572,20 @@ public int compare(FileStatus o1, FileStatus o2) { storeRestart(loader); assertEquals(0, loader.getLoadedCount()); assertEquals(rootProcs.length, loader.getCorruptedCount()); - for (Procedure proc: loader.getCorrupted()) { + for (Procedure proc : loader.getCorrupted()) { assertTrue(proc.toString(), proc.getParentProcId() <= rootProcs.length); assertTrue(proc.toString(), - proc.getProcId() > rootProcs.length && - proc.getProcId() <= (rootProcs.length * 2)); + proc.getProcId() > rootProcs.length && proc.getProcId() <= (rootProcs.length * 2)); } } - @Test - public void testWalReplayOrder_AB_A() throws Exception { - /* - * | A B | -> | A | - */ - TestProcedure a = new TestProcedure(1, 0); - TestProcedure b = new TestProcedure(2, 1); - - procStore.insert(a, null); - a.addStackId(0); - procStore.update(a); - - procStore.insert(a, new Procedure[] { b }); - b.addStackId(1); - procStore.update(b); - - procStore.rollWriterForTesting(); - - a.addStackId(2); - procStore.update(a); - - storeRestart(new ProcedureStore.ProcedureLoader() { - @Override - public void setMaxProcId(long maxProcId) { - assertEquals(2, maxProcId); - } - - @Override - public void load(ProcedureIterator procIter) throws IOException { - assertTrue(procIter.hasNext()); - assertEquals(1, procIter.next().getProcId()); - assertTrue(procIter.hasNext()); - assertEquals(2, procIter.next().getProcId()); - assertFalse(procIter.hasNext()); - } - - @Override - public void handleCorrupted(ProcedureIterator procIter) throws IOException { - assertFalse(procIter.hasNext()); - } - }); - } - - @Test - public void testWalReplayOrder_ABC_BAD() throws Exception { - /* - * | A B C | -> | B A D | - */ - TestProcedure a = new TestProcedure(1, 0); - TestProcedure b = new TestProcedure(2, 1); - TestProcedure c = new TestProcedure(3, 2); - TestProcedure d = new TestProcedure(4, 0); - - procStore.insert(a, null); - a.addStackId(0); - procStore.update(a); - - procStore.insert(a, new Procedure[] { b }); - b.addStackId(1); - procStore.update(b); - - procStore.insert(b, new Procedure[] { c }); - b.addStackId(2); - procStore.update(b); - - procStore.rollWriterForTesting(); - - b.addStackId(3); - procStore.update(b); - - a.addStackId(4); - procStore.update(a); - - procStore.insert(d, null); - d.addStackId(0); - procStore.update(d); - - storeRestart(new ProcedureStore.ProcedureLoader() { - @Override - public void setMaxProcId(long maxProcId) { - assertEquals(4, maxProcId); - } - - @Override - public void load(ProcedureIterator procIter) throws IOException { - assertTrue(procIter.hasNext()); - assertEquals(4, procIter.next().getProcId()); - // TODO: This will be multiple call once we do fast-start - //assertFalse(procIter.hasNext()); - - assertTrue(procIter.hasNext()); - assertEquals(1, procIter.next().getProcId()); - assertTrue(procIter.hasNext()); - assertEquals(2, procIter.next().getProcId()); - assertTrue(procIter.hasNext()); - assertEquals(3, procIter.next().getProcId()); - assertFalse(procIter.hasNext()); - } - - @Override - public void handleCorrupted(ProcedureIterator procIter) throws IOException { - assertFalse(procIter.hasNext()); - } - }); - } - @Test public void testRollAndRemove() throws IOException { // Insert something in the log - Procedure proc1 = new TestSequentialProcedure(); + Procedure proc1 = new TestSequentialProcedure(); procStore.insert(proc1, null); - Procedure proc2 = new TestSequentialProcedure(); + Procedure proc2 = new TestSequentialProcedure(); procStore.insert(proc2, null); // roll the log, now we have 2 @@ -942,17 +832,6 @@ private void verifyProcIdsOnRestart(final Set procIds) throws Exception { assertEquals(0, loader.getCorruptedCount()); } - private void assertEmptyLogDir() { - try { - FileStatus[] status = fs.listStatus(logDir); - assertTrue("expected empty state-log dir", status == null || status.length == 0); - } catch (FileNotFoundException e) { - fail("expected the state-log dir to be present: " + logDir); - } catch (IOException e) { - fail("got en exception on state-log dir list: " + e.getMessage()); - } - } - public static class TestSequentialProcedure extends SequentialProcedure { private static long seqid = 0; @@ -961,13 +840,18 @@ public TestSequentialProcedure() { } @Override - protected Procedure[] execute(Void env) { return null; } + protected Procedure[] execute(Void env) { + return null; + } @Override - protected void rollback(Void env) { } + protected void rollback(Void env) { + } @Override - protected boolean abort(Void env) { return false; } + protected boolean abort(Void env) { + return false; + } @Override protected void serializeStateData(ProcedureStateSerializer serializer) diff --git a/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureTree.java b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureTree.java new file mode 100644 index 000000000000..890d0e3e9c0e --- /dev/null +++ b/hbase-procedure/src/test/java/org/apache/hadoop/hbase/procedure2/store/wal/TestWALProcedureTree.java @@ -0,0 +1,173 @@ +/** + * 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.procedure2.store.wal; + +import static org.junit.Assert.assertEquals; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; +import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; +import org.apache.hadoop.hbase.procedure2.ProcedureUtil; +import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureIterator; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; + +@Category({ MasterTests.class, SmallTests.class }) +public class TestWALProcedureTree { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestWALProcedureTree.class); + + public static final class TestProcedure extends Procedure { + + @Override + public void setProcId(long procId) { + super.setProcId(procId); + } + + @Override + public void setParentProcId(long parentProcId) { + super.setParentProcId(parentProcId); + } + + @Override + public synchronized void addStackIndex(int index) { + super.addStackIndex(index); + } + + @Override + protected Procedure[] execute(Void env) + throws ProcedureYieldException, ProcedureSuspendedException, InterruptedException { + return null; + } + + @Override + protected void rollback(Void env) throws IOException, InterruptedException { + } + + @Override + protected boolean abort(Void env) { + return false; + } + + @Override + protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + + @Override + protected void deserializeStateData(ProcedureStateSerializer serializer) throws IOException { + } + } + + private TestProcedure createProc(long procId, long parentProcId) { + TestProcedure proc = new TestProcedure(); + proc.setProcId(procId); + if (parentProcId != Procedure.NO_PROC_ID) { + proc.setParentProcId(parentProcId); + } + return proc; + } + + private List toProtos(TestProcedure... procs) { + return Arrays.stream(procs).map(p -> { + try { + return ProcedureUtil.convertToProtoProcedure(p); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + }).collect(Collectors.toList()); + } + + private List getProcs(ProcedureIterator iter) throws IOException { + List procs = new ArrayList<>(); + while (iter.hasNext()) { + procs.add((TestProcedure) iter.next()); + } + return procs; + } + + @Test + public void testMissingStackId() throws IOException { + TestProcedure proc0 = createProc(1, Procedure.NO_PROC_ID); + proc0.addStackIndex(0); + TestProcedure proc1 = createProc(2, 1); + proc1.addStackIndex(1); + TestProcedure proc2 = createProc(3, 2); + proc2.addStackIndex(3); + WALProcedureTree tree = WALProcedureTree.build(toProtos(proc0, proc1, proc2)); + List validProcs = getProcs(tree.getValidProcs()); + assertEquals(0, validProcs.size()); + List corruptedProcs = getProcs(tree.getCorruptedProcs()); + assertEquals(3, corruptedProcs.size()); + assertEquals(1, corruptedProcs.get(0).getProcId()); + assertEquals(2, corruptedProcs.get(1).getProcId()); + assertEquals(3, corruptedProcs.get(2).getProcId()); + } + + @Test + public void testDuplicatedStackId() throws IOException { + TestProcedure proc0 = createProc(1, Procedure.NO_PROC_ID); + proc0.addStackIndex(0); + TestProcedure proc1 = createProc(2, 1); + proc1.addStackIndex(1); + TestProcedure proc2 = createProc(3, 2); + proc2.addStackIndex(1); + WALProcedureTree tree = WALProcedureTree.build(toProtos(proc0, proc1, proc2)); + List validProcs = getProcs(tree.getValidProcs()); + assertEquals(0, validProcs.size()); + List corruptedProcs = getProcs(tree.getCorruptedProcs()); + assertEquals(3, corruptedProcs.size()); + assertEquals(1, corruptedProcs.get(0).getProcId()); + assertEquals(2, corruptedProcs.get(1).getProcId()); + assertEquals(3, corruptedProcs.get(2).getProcId()); + } + + @Test + public void testOrphan() throws IOException { + TestProcedure proc0 = createProc(1, Procedure.NO_PROC_ID); + proc0.addStackIndex(0); + TestProcedure proc1 = createProc(2, 1); + proc1.addStackIndex(1); + TestProcedure proc2 = createProc(3, Procedure.NO_PROC_ID); + proc2.addStackIndex(0); + TestProcedure proc3 = createProc(5, 4); + proc3.addStackIndex(1); + WALProcedureTree tree = WALProcedureTree.build(toProtos(proc0, proc1, proc2, proc3)); + List validProcs = getProcs(tree.getValidProcs()); + assertEquals(3, validProcs.size()); + List corruptedProcs = getProcs(tree.getCorruptedProcs()); + assertEquals(1, corruptedProcs.size()); + assertEquals(5, corruptedProcs.get(0).getProcId()); + assertEquals(4, corruptedProcs.get(0).getParentProcId()); + } + +} diff --git a/hbase-protocol-shaded/src/main/protobuf/Cell.proto b/hbase-protocol-shaded/src/main/protobuf/Cell.proto index 0e9eb94b5e8e..aada35329aaf 100644 --- a/hbase-protocol-shaded/src/main/protobuf/Cell.proto +++ b/hbase-protocol-shaded/src/main/protobuf/Cell.proto @@ -32,6 +32,7 @@ enum CellType { PUT = 4; DELETE = 8; + DELETE_FAMILY_VERSION = 10; DELETE_COLUMN = 12; DELETE_FAMILY = 14; diff --git a/hbase-protocol-shaded/src/main/protobuf/Master.proto b/hbase-protocol-shaded/src/main/protobuf/Master.proto index 69e0f32d07e4..8318da39c2c8 100644 --- a/hbase-protocol-shaded/src/main/protobuf/Master.proto +++ b/hbase-protocol-shaded/src/main/protobuf/Master.proto @@ -99,6 +99,7 @@ message MergeTableRegionsResponse { message AssignRegionRequest { required RegionSpecifier region = 1; + optional bool override = 2 [default = false]; } message AssignRegionResponse { @@ -485,10 +486,6 @@ message GetTableStateResponse { required TableState table_state = 1; } -message SetTableStateInMetaRequest { - required TableName table_name = 1; - required TableState table_state = 2; -} message GetClusterStatusRequest { repeated Option options = 1; @@ -997,8 +994,82 @@ service MasterService { } +// HBCK Service definitions. + +message SetTableStateInMetaRequest { + required TableName table_name = 1; + required TableState table_state = 2; +} + +/** Like Admin's AssignRegionRequest except it can + * take one or more Regions at a time. + */ +// NOTE: In hbck.proto, there is a define for +// AssignRegionRequest -- singular 'Region'. This +// is plural to convey it can carry more than one +// Region at a time. +message AssignsRequest { + repeated RegionSpecifier region = 1; + optional bool override = 2 [default = false]; +} + +/** Like Admin's AssignRegionResponse except it can + * return one or more pids as result -- one per assign. + */ +message AssignsResponse { + repeated uint64 pid = 1; +} + +/** Like Admin's UnassignRegionRequest except it can + * take one or more Regions at a time. + */ +message UnassignsRequest { + repeated RegionSpecifier region = 1; + optional bool override = 2 [default = false]; +} + +/** Like Admin's UnassignRegionResponse except it can + * return one or more pids as result -- one per unassign. + */ +message UnassignsResponse { + repeated uint64 pid = 1; +} + +message BypassProcedureRequest { + repeated uint64 proc_id = 1; + optional uint64 waitTime = 2; // wait time in ms to acquire lock on a procedure + optional bool override = 3 [default = false]; // if true, procedure is marked for bypass even if its executing + optional bool recursive = 4; +} + +message BypassProcedureResponse { + repeated bool bypassed = 1; +} + service HbckService { /** Update state of the table in meta only*/ rpc SetTableStateInMeta(SetTableStateInMetaRequest) returns(GetTableStateResponse); + + /** + * Assign regions. + * Like Admin's assign but works even if the + * Master is initializing. Also allows bulk'ing up + * assigns rather than one region at a time. + */ + rpc Assigns(AssignsRequest) + returns(AssignsResponse); + + /** + * Unassign regions + * Like Admin's unssign but works even if the + * Master is initializing. Also allows bulk'ing up + * assigns rather than one region at a time. + */ + rpc Unassigns(UnassignsRequest) + returns(UnassignsResponse); + + /** Bypass a procedure to completion, procedure is completed but no actual work is done*/ + rpc BypassProcedure(BypassProcedureRequest) + returns(BypassProcedureResponse); } diff --git a/hbase-protocol-shaded/src/main/protobuf/MasterProcedure.proto b/hbase-protocol-shaded/src/main/protobuf/MasterProcedure.proto index e50a9137bb77..07d1a55af5bd 100644 --- a/hbase-protocol-shaded/src/main/protobuf/MasterProcedure.proto +++ b/hbase-protocol-shaded/src/main/protobuf/MasterProcedure.proto @@ -533,6 +533,7 @@ message RegionStateTransitionStateData { required RegionStateTransitionState lastState = 2; optional ServerName assign_candidate = 3; required bool force_new_plan = 4; + optional bool override = 5 [default = false]; } message RegionRemoteProcedureBaseStateData { diff --git a/hbase-protocol/src/main/protobuf/Cell.proto b/hbase-protocol/src/main/protobuf/Cell.proto index 2c6103540fb8..e518e658f63b 100644 --- a/hbase-protocol/src/main/protobuf/Cell.proto +++ b/hbase-protocol/src/main/protobuf/Cell.proto @@ -32,6 +32,7 @@ enum CellType { PUT = 4; DELETE = 8; + DELETE_FAMILY_VERSION = 10; DELETE_COLUMN = 12; DELETE_FAMILY = 14; diff --git a/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ReplicationQueueStorage.java b/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ReplicationQueueStorage.java index 84653adbf6d1..59278e9807d5 100644 --- a/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ReplicationQueueStorage.java +++ b/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ReplicationQueueStorage.java @@ -202,4 +202,11 @@ Pair> claimQueue(ServerName sourceServerName, String q * created hfile references during the call may not be included. */ Set getAllHFileRefs() throws ReplicationException; + + /** + * Get full znode name for given region server + * @param serverName the name of the region server + * @return full znode name + */ + String getRsNode(ServerName serverName); } diff --git a/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ZKReplicationQueueStorage.java b/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ZKReplicationQueueStorage.java index cca8bfcab3da..68f2adc2e8b0 100644 --- a/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ZKReplicationQueueStorage.java +++ b/hbase-replication/src/main/java/org/apache/hadoop/hbase/replication/ZKReplicationQueueStorage.java @@ -118,7 +118,8 @@ public ZKReplicationQueueStorage(ZKWatcher zookeeper, Configuration conf) { .get(ZOOKEEPER_ZNODE_REPLICATION_REGIONS_KEY, ZOOKEEPER_ZNODE_REPLICATION_REGIONS_DEFAULT)); } - private String getRsNode(ServerName serverName) { + @Override + public String getRsNode(ServerName serverName) { return ZNodePaths.joinZNode(queuesZNode, serverName.getServerName()); } diff --git a/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupBasedLoadBalancer.java b/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupBasedLoadBalancer.java index 5c70ecf34fe3..500650026d24 100644 --- a/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupBasedLoadBalancer.java +++ b/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupBasedLoadBalancer.java @@ -478,4 +478,8 @@ public void setRsGroupInfoManager(RSGroupInfoManager rsGroupInfoManager) { public void postMasterStartupInitialize() { this.internalBalancer.postMasterStartupInitialize(); } + + public void updateBalancerStatus(boolean status) { + internalBalancer.updateBalancerStatus(status); + } } diff --git a/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java b/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java index ee0651b4918f..4a881d30d928 100644 --- a/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java +++ b/hbase-rsgroup/src/main/java/org/apache/hadoop/hbase/rsgroup/RSGroupInfoManagerImpl.java @@ -65,6 +65,7 @@ import org.apache.hadoop.hbase.master.ServerListener; import org.apache.hadoop.hbase.master.TableStateManager; import org.apache.hadoop.hbase.master.assignment.RegionStateNode; +import org.apache.hadoop.hbase.master.procedure.MasterProcedureUtil; import org.apache.hadoop.hbase.net.Address; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.protobuf.ProtobufMagic; @@ -874,7 +875,7 @@ private void createRSGroupTable() throws IOException { Procedure result = masterServices.getMasterProcedureExecutor().getResult(procId); if (result != null && result.isFailed()) { throw new IOException("Failed to create group table. " + - result.getException().unwrapRemoteIOException()); + MasterProcedureUtil.unwrapRemoteIOException(result)); } } } diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestEnableRSGroup.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestEnableRSGroups.java similarity index 93% rename from hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestEnableRSGroup.java rename to hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestEnableRSGroups.java index 77faec70f4fc..d15c7a89f864 100644 --- a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestEnableRSGroup.java +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestEnableRSGroups.java @@ -40,13 +40,13 @@ * Test enable RSGroup */ @Category({ MediumTests.class }) -public class TestEnableRSGroup { +public class TestEnableRSGroups { @ClassRule public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestEnableRSGroup.class); + HBaseClassTestRule.forClass(TestEnableRSGroups.class); - protected static final Logger LOG = LoggerFactory.getLogger(TestEnableRSGroup.class); + protected static final Logger LOG = LoggerFactory.getLogger(TestEnableRSGroups.class); private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); @@ -71,7 +71,8 @@ public void testEnableRSGroup() throws IOException, InterruptedException { LOG.info("stopped master..."); final Configuration conf = TEST_UTIL.getMiniHBaseCluster().getConfiguration(); conf.set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, RSGroupAdminEndpoint.class.getName()); - conf.set(HConstants.HBASE_MASTER_LOADBALANCER_CLASS, RSGroupBasedLoadBalancer.class.getName()); + conf.set(HConstants.HBASE_MASTER_LOADBALANCER_CLASS, + RSGroupBasedLoadBalancer.class.getName()); TEST_UTIL.getMiniHBaseCluster().startMaster(); TEST_UTIL.getMiniHBaseCluster().waitForActiveAndReadyMaster(60000); diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroups.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroups.java deleted file mode 100644 index 2fac94c6c7ac..000000000000 --- a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroups.java +++ /dev/null @@ -1,616 +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.rsgroup; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; - -import java.io.IOException; -import java.util.Iterator; -import java.util.List; -import java.util.Optional; -import java.util.Set; - -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HTableDescriptor; -import org.apache.hadoop.hbase.MiniHBaseCluster; -import org.apache.hadoop.hbase.NamespaceDescriptor; -import org.apache.hadoop.hbase.ServerName; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.Waiter; -import org.apache.hadoop.hbase.Waiter.Predicate; -import org.apache.hadoop.hbase.client.ClusterConnection; -import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; -import org.apache.hadoop.hbase.coprocessor.MasterCoprocessor; -import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment; -import org.apache.hadoop.hbase.coprocessor.MasterObserver; -import org.apache.hadoop.hbase.coprocessor.ObserverContext; -import org.apache.hadoop.hbase.master.MasterCoprocessorHost; -import org.apache.hadoop.hbase.master.ServerManager; -import org.apache.hadoop.hbase.master.TableNamespaceManager; -import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; -import org.apache.hadoop.hbase.net.Address; -import org.apache.hadoop.hbase.quotas.QuotaTableUtil; -import org.apache.hadoop.hbase.quotas.QuotaUtil; -import org.apache.hadoop.hbase.testclassification.MediumTests; -import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Assert; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import org.apache.hbase.thirdparty.com.google.common.collect.Sets; - -import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; -import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; - -@Category({MediumTests.class}) -public class TestRSGroups extends TestRSGroupsBase { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRSGroups.class); - - protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroups.class); - private static boolean INIT = false; - private static RSGroupAdminEndpoint rsGroupAdminEndpoint; - private static CPMasterObserver observer; - - @BeforeClass - public static void setUp() throws Exception { - TEST_UTIL = new HBaseTestingUtility(); - TEST_UTIL.getConfiguration().setFloat( - "hbase.master.balancer.stochastic.tableSkewCost", 6000); - TEST_UTIL.getConfiguration().set( - HConstants.HBASE_MASTER_LOADBALANCER_CLASS, - RSGroupBasedLoadBalancer.class.getName()); - TEST_UTIL.getConfiguration().set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, - RSGroupAdminEndpoint.class.getName() + "," + CPMasterObserver.class.getName()); - TEST_UTIL.startMiniCluster(NUM_SLAVES_BASE - 1); - TEST_UTIL.getConfiguration().setInt( - ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, - NUM_SLAVES_BASE - 1); - TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); - initialize(); - } - - private static void initialize() throws Exception { - admin = TEST_UTIL.getAdmin(); - cluster = TEST_UTIL.getHBaseCluster(); - master = ((MiniHBaseCluster)cluster).getMaster(); - - //wait for balancer to come online - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return master.isInitialized() && - ((RSGroupBasedLoadBalancer) master.getLoadBalancer()).isOnline(); - } - }); - admin.setBalancerRunning(false,true); - rsGroupAdmin = new VerifyingRSGroupAdminClient( - new RSGroupAdminClient(TEST_UTIL.getConnection()), TEST_UTIL.getConfiguration()); - MasterCoprocessorHost host = master.getMasterCoprocessorHost(); - observer = (CPMasterObserver) host.findCoprocessor(CPMasterObserver.class.getName()); - rsGroupAdminEndpoint = (RSGroupAdminEndpoint) - host.findCoprocessor(RSGroupAdminEndpoint.class.getName()); - } - - @AfterClass - public static void tearDown() throws Exception { - TEST_UTIL.shutdownMiniCluster(); - } - - @Before - public void beforeMethod() throws Exception { - if (!INIT) { - INIT = true; - afterMethod(); - } - - } - - @After - public void afterMethod() throws Exception { - deleteTableIfNecessary(); - deleteNamespaceIfNecessary(); - deleteGroups(); - - for(ServerName sn : admin.listDecommissionedRegionServers()){ - admin.recommissionRegionServer(sn, null); - } - assertTrue(admin.listDecommissionedRegionServers().isEmpty()); - - int missing = NUM_SLAVES_BASE - getNumServers(); - LOG.info("Restoring servers: "+missing); - for(int i=0; i() { - @Override - public boolean evaluate() throws Exception { - LOG.info("Waiting for cleanup to finish " + rsGroupAdmin.listRSGroups()); - //Might be greater since moving servers back to default - //is after starting a server - - return rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size() - == NUM_SLAVES_BASE; - } - }); - } - - @Test - public void testBasicStartUp() throws IOException { - RSGroupInfo defaultInfo = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); - assertEquals(4, defaultInfo.getServers().size()); - // Assignment of root and meta regions. - int count = master.getAssignmentManager().getRegionStates().getRegionAssignments().size(); - //3 meta,namespace, group - assertEquals(3, count); - } - - @Test - public void testNamespaceCreateAndAssign() throws Exception { - LOG.info("testNamespaceCreateAndAssign"); - String nsName = tablePrefix+"_foo"; - final TableName tableName = TableName.valueOf(nsName, tablePrefix + "_testCreateAndAssign"); - RSGroupInfo appInfo = addGroup("appInfo", 1); - admin.createNamespace(NamespaceDescriptor.create(nsName) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "appInfo").build()); - final HTableDescriptor desc = new HTableDescriptor(tableName); - desc.addFamily(new HColumnDescriptor("f")); - admin.createTable(desc); - //wait for created table to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getTableRegionMap().get(desc.getTableName()) != null; - } - }); - ServerName targetServer = - ServerName.parseServerName(appInfo.getServers().iterator().next().toString()); - AdminProtos.AdminService.BlockingInterface rs = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - //verify it was assigned to the right group - Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(rs).size()); - } - - @Test - public void testDefaultNamespaceCreateAndAssign() throws Exception { - LOG.info("testDefaultNamespaceCreateAndAssign"); - String tableName = tablePrefix + "_testCreateAndAssign"; - admin.modifyNamespace(NamespaceDescriptor.create("default") - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "default").build()); - final HTableDescriptor desc = new HTableDescriptor(TableName.valueOf(tableName)); - desc.addFamily(new HColumnDescriptor("f")); - admin.createTable(desc); - //wait for created table to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getTableRegionMap().get(desc.getTableName()) != null; - } - }); - } - - @Test - public void testNamespaceConstraint() throws Exception { - String nsName = tablePrefix+"_foo"; - String groupName = tablePrefix+"_foo"; - LOG.info("testNamespaceConstraint"); - rsGroupAdmin.addRSGroup(groupName); - assertTrue(observer.preAddRSGroupCalled); - assertTrue(observer.postAddRSGroupCalled); - - admin.createNamespace(NamespaceDescriptor.create(nsName) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, groupName) - .build()); - //test removing a referenced group - try { - rsGroupAdmin.removeRSGroup(groupName); - fail("Expected a constraint exception"); - } catch (IOException ex) { - } - //test modify group - //changing with the same name is fine - admin.modifyNamespace( - NamespaceDescriptor.create(nsName) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, groupName) - .build()); - String anotherGroup = tablePrefix+"_anotherGroup"; - rsGroupAdmin.addRSGroup(anotherGroup); - //test add non-existent group - admin.deleteNamespace(nsName); - rsGroupAdmin.removeRSGroup(groupName); - assertTrue(observer.preRemoveRSGroupCalled); - assertTrue(observer.postRemoveRSGroupCalled); - try { - admin.createNamespace(NamespaceDescriptor.create(nsName) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "foo") - .build()); - fail("Expected a constraint exception"); - } catch (IOException ex) { - } - } - - @Test - public void testGroupInfoMultiAccessing() throws Exception { - RSGroupInfoManager manager = rsGroupAdminEndpoint.getGroupInfoManager(); - RSGroupInfo defaultGroup = manager.getRSGroup("default"); - // getRSGroup updates default group's server list - // this process must not affect other threads iterating the list - Iterator

it = defaultGroup.getServers().iterator(); - manager.getRSGroup("default"); - it.next(); - } - - public static class CPMasterObserver implements MasterCoprocessor, MasterObserver { - boolean preBalanceRSGroupCalled = false; - boolean postBalanceRSGroupCalled = false; - boolean preMoveServersCalled = false; - boolean postMoveServersCalled = false; - boolean preMoveTablesCalled = false; - boolean postMoveTablesCalled = false; - boolean preAddRSGroupCalled = false; - boolean postAddRSGroupCalled = false; - boolean preRemoveRSGroupCalled = false; - boolean postRemoveRSGroupCalled = false; - boolean preRemoveServersCalled = false; - boolean postRemoveServersCalled = false; - boolean preMoveServersAndTables = false; - boolean postMoveServersAndTables = false; - boolean preGetRSGroupInfoCalled = false; - boolean postGetRSGroupInfoCalled = false; - boolean preGetRSGroupInfoOfTableCalled = false; - boolean postGetRSGroupInfoOfTableCalled = false; - boolean preListRSGroupsCalled = false; - boolean postListRSGroupsCalled = false; - boolean preGetRSGroupInfoOfServerCalled = false; - boolean postGetRSGroupInfoOfServerCalled = false; - - @Override - public Optional getMasterObserver() { - return Optional.of(this); - } - @Override - public void preMoveServersAndTables(final ObserverContext ctx, - Set
servers, Set tables, String targetGroup) throws IOException { - preMoveServersAndTables = true; - } - @Override - public void postMoveServersAndTables(final ObserverContext ctx, - Set
servers, Set tables, String targetGroup) throws IOException { - postMoveServersAndTables = true; - } - @Override - public void preRemoveServers( - final ObserverContext ctx, - Set
servers) throws IOException { - preRemoveServersCalled = true; - } - @Override - public void postRemoveServers( - final ObserverContext ctx, - Set
servers) throws IOException { - postRemoveServersCalled = true; - } - @Override - public void preRemoveRSGroup(final ObserverContext ctx, - String name) throws IOException { - preRemoveRSGroupCalled = true; - } - @Override - public void postRemoveRSGroup(final ObserverContext ctx, - String name) throws IOException { - postRemoveRSGroupCalled = true; - } - @Override - public void preAddRSGroup(final ObserverContext ctx, - String name) throws IOException { - preAddRSGroupCalled = true; - } - @Override - public void postAddRSGroup(final ObserverContext ctx, - String name) throws IOException { - postAddRSGroupCalled = true; - } - @Override - public void preMoveTables(final ObserverContext ctx, - Set tables, String targetGroup) throws IOException { - preMoveTablesCalled = true; - } - @Override - public void postMoveTables(final ObserverContext ctx, - Set tables, String targetGroup) throws IOException { - postMoveTablesCalled = true; - } - @Override - public void preMoveServers(final ObserverContext ctx, - Set
servers, String targetGroup) throws IOException { - preMoveServersCalled = true; - } - - @Override - public void postMoveServers(final ObserverContext ctx, - Set
servers, String targetGroup) throws IOException { - postMoveServersCalled = true; - } - @Override - public void preBalanceRSGroup(final ObserverContext ctx, - String groupName) throws IOException { - preBalanceRSGroupCalled = true; - } - @Override - public void postBalanceRSGroup(final ObserverContext ctx, - String groupName, boolean balancerRan) throws IOException { - postBalanceRSGroupCalled = true; - } - - @Override - public void preGetRSGroupInfo(final ObserverContext ctx, - final String groupName) throws IOException { - preGetRSGroupInfoCalled = true; - } - - @Override - public void postGetRSGroupInfo(final ObserverContext ctx, - final String groupName) throws IOException { - postGetRSGroupInfoCalled = true; - } - - @Override - public void preGetRSGroupInfoOfTable(final ObserverContext ctx, - final TableName tableName) throws IOException { - preGetRSGroupInfoOfTableCalled = true; - } - - @Override - public void postGetRSGroupInfoOfTable(final ObserverContext ctx, - final TableName tableName) throws IOException { - postGetRSGroupInfoOfTableCalled = true; - } - - @Override - public void preListRSGroups(final ObserverContext ctx) - throws IOException { - preListRSGroupsCalled = true; - } - - @Override - public void postListRSGroups(final ObserverContext ctx) - throws IOException { - postListRSGroupsCalled = true; - } - - @Override - public void preGetRSGroupInfoOfServer(final ObserverContext ctx, - final Address server) throws IOException { - preGetRSGroupInfoOfServerCalled = true; - } - - @Override - public void postGetRSGroupInfoOfServer(final ObserverContext ctx, - final Address server) throws IOException { - postGetRSGroupInfoOfServerCalled = true; - } - } - - @Test - public void testGetRSGroupInfoCPHookCalled() throws Exception { - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); - assertTrue(observer.preGetRSGroupInfoCalled); - assertTrue(observer.postGetRSGroupInfoCalled); - } - - @Test - public void testGetRSGroupInfoOfTableCPHookCalled() throws Exception { - rsGroupAdmin.getRSGroupInfoOfTable(TableName.META_TABLE_NAME); - assertTrue(observer.preGetRSGroupInfoOfTableCalled); - assertTrue(observer.postGetRSGroupInfoOfTableCalled); - } - - @Test - public void testListRSGroupsCPHookCalled() throws Exception { - rsGroupAdmin.listRSGroups(); - assertTrue(observer.preListRSGroupsCalled); - assertTrue(observer.postListRSGroupsCalled); - } - - @Test - public void testGetRSGroupInfoOfServerCPHookCalled() throws Exception { - ServerName masterServerName = ((MiniHBaseCluster) cluster).getMaster().getServerName(); - rsGroupAdmin.getRSGroupOfServer(masterServerName.getAddress()); - assertTrue(observer.preGetRSGroupInfoOfServerCalled); - assertTrue(observer.postGetRSGroupInfoOfServerCalled); - } - - @Test - public void testMoveServersAndTables() throws Exception { - super.testMoveServersAndTables(); - assertTrue(observer.preMoveServersAndTables); - assertTrue(observer.postMoveServersAndTables); - } - @Test - public void testTableMoveTruncateAndDrop() throws Exception { - super.testTableMoveTruncateAndDrop(); - assertTrue(observer.preMoveTablesCalled); - assertTrue(observer.postMoveTablesCalled); - } - - @Test - public void testRemoveServers() throws Exception { - super.testRemoveServers(); - assertTrue(observer.preRemoveServersCalled); - assertTrue(observer.postRemoveServersCalled); - } - - @Test - public void testMisplacedRegions() throws Exception { - final TableName tableName = TableName.valueOf(tablePrefix+"_testMisplacedRegions"); - LOG.info("testMisplacedRegions"); - - final RSGroupInfo RSGroupInfo = addGroup("testMisplacedRegions", 1); - - TEST_UTIL.createMultiRegionTable(tableName, new byte[]{'f'}, 15); - TEST_UTIL.waitUntilAllRegionsAssigned(tableName); - - rsGroupAdminEndpoint.getGroupInfoManager() - .moveTables(Sets.newHashSet(tableName), RSGroupInfo.getName()); - - admin.setBalancerRunning(true,true); - assertTrue(rsGroupAdmin.balanceRSGroup(RSGroupInfo.getName())); - admin.setBalancerRunning(false,true); - assertTrue(observer.preBalanceRSGroupCalled); - assertTrue(observer.postBalanceRSGroupCalled); - - TEST_UTIL.waitFor(60000, new Predicate() { - @Override - public boolean evaluate() throws Exception { - ServerName serverName = - ServerName.valueOf(RSGroupInfo.getServers().iterator().next().toString(), 1); - return admin.getConnection().getAdmin() - .getOnlineRegions(serverName).size() == 15; - } - }); - } - - @Test - public void testCloneSnapshot() throws Exception { - byte[] FAMILY = Bytes.toBytes("test"); - String snapshotName = tableName.getNameAsString() + "_snap"; - TableName clonedTableName = TableName.valueOf(tableName.getNameAsString() + "_clone"); - - // create base table - TEST_UTIL.createTable(tableName, FAMILY); - - // create snapshot - admin.snapshot(snapshotName, tableName); - - // clone - admin.cloneSnapshot(snapshotName, clonedTableName); - } - - @Test - public void testRSGroupsWithHBaseQuota() throws Exception { - TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, true); - restartHBaseCluster(); - try { - TEST_UTIL.waitFor(90000, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return admin.isTableAvailable(QuotaTableUtil.QUOTA_TABLE_NAME); - } - }); - } finally { - TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, false); - restartHBaseCluster(); - } - } - - @Test - public void testRSGroupListDoesNotContainFailedTableCreation() throws Exception { - toggleQuotaCheckAndRestartMiniCluster(true); - String nsp = "np1"; - NamespaceDescriptor nspDesc = - NamespaceDescriptor.create(nsp).addConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "5") - .addConfiguration(TableNamespaceManager.KEY_MAX_TABLES, "2").build(); - admin.createNamespace(nspDesc); - assertEquals(3, admin.listNamespaceDescriptors().length); - HColumnDescriptor fam1 = new HColumnDescriptor("fam1"); - HTableDescriptor tableDescOne = - new HTableDescriptor(TableName.valueOf(nsp + TableName.NAMESPACE_DELIM + "table1")); - tableDescOne.addFamily(fam1); - admin.createTable(tableDescOne); - - HTableDescriptor tableDescTwo = - new HTableDescriptor(TableName.valueOf(nsp + TableName.NAMESPACE_DELIM + "table2")); - tableDescTwo.addFamily(fam1); - boolean constraintViolated = false; - - try { - admin.createTable(tableDescTwo, Bytes.toBytes("AAA"), Bytes.toBytes("ZZZ"), - 6); - Assert.fail("Creation table should fail because of quota violation."); - } catch (Exception exp) { - assertTrue(exp instanceof IOException); - constraintViolated = true; - } finally { - assertTrue("Constraint not violated for table " + tableDescTwo.getTableName(), - constraintViolated); - } - List rsGroupInfoList = rsGroupAdmin.listRSGroups(); - boolean foundTable2 = false; - boolean foundTable1 = false; - for(int i = 0; i < rsGroupInfoList.size(); i++){ - if(rsGroupInfoList.get(i).getTables().contains(tableDescTwo.getTableName())){ - foundTable2 = true; - } - if(rsGroupInfoList.get(i).getTables().contains(tableDescOne.getTableName())){ - foundTable1 = true; - } - } - assertFalse("Found table2 in rsgroup list.", foundTable2); - assertTrue("Did not find table1 in rsgroup list", foundTable1); - - TEST_UTIL.deleteTable(tableDescOne.getTableName()); - admin.deleteNamespace(nspDesc.getName()); - toggleQuotaCheckAndRestartMiniCluster(false); - - } - private void toggleQuotaCheckAndRestartMiniCluster(boolean enable) throws Exception{ - TEST_UTIL.shutdownMiniCluster(); - TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, enable); - TEST_UTIL.startMiniCluster(NUM_SLAVES_BASE - 1); - TEST_UTIL.getConfiguration().setInt( - ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, - NUM_SLAVES_BASE - 1); - TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); - initialize(); - } - - private void restartHBaseCluster() throws Exception { - LOG.info("\n\nShutting down cluster"); - TEST_UTIL.shutdownMiniHBaseCluster(); - LOG.info("\n\nSleeping a bit"); - Thread.sleep(2000); - TEST_UTIL.restartHBaseCluster(NUM_SLAVES_BASE - 1); - initialize(); - } -} diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsAdmin1.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsAdmin1.java new file mode 100644 index 000000000000..89d1930730fc --- /dev/null +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsAdmin1.java @@ -0,0 +1,502 @@ +/** + * 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.rsgroup; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.IOException; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HColumnDescriptor; +import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.MiniHBaseCluster; +import org.apache.hadoop.hbase.NamespaceDescriptor; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.TableNotFoundException; +import org.apache.hadoop.hbase.Waiter; +import org.apache.hadoop.hbase.constraint.ConstraintException; +import org.apache.hadoop.hbase.master.ServerManager; +import org.apache.hadoop.hbase.master.TableNamespaceManager; +import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; +import org.apache.hadoop.hbase.net.Address; +import org.apache.hadoop.hbase.quotas.QuotaUtil; +import org.apache.hadoop.hbase.util.Bytes; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hbase.thirdparty.com.google.common.collect.Sets; + +@Category({MediumTests.class}) +public class TestRSGroupsAdmin1 extends TestRSGroupsBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRSGroupsAdmin1.class); + + protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroupsAdmin1.class); + + @BeforeClass + public static void setUp() throws Exception { + setUpTestBeforeClass(); + } + + @AfterClass + public static void tearDown() throws Exception { + tearDownAfterClass(); + } + + @Before + public void beforeMethod() throws Exception { + setUpBeforeMethod(); + } + + @After + public void afterMethod() throws Exception { + tearDownAfterMethod(); + } + + @Test + public void testValidGroupNames() throws IOException { + String[] badNames = {"foo*","foo@","-"}; + String[] goodNames = {"foo_123"}; + + for(String entry: badNames) { + try { + rsGroupAdmin.addRSGroup(entry); + fail("Expected a constraint exception for: "+entry); + } catch(ConstraintException ex) { + //expected + } + } + + for(String entry: goodNames) { + rsGroupAdmin.addRSGroup(entry); + } + } + + @Test + public void testBogusArgs() throws Exception { + assertNull(rsGroupAdmin.getRSGroupInfoOfTable(TableName.valueOf("nonexistent"))); + assertNull(rsGroupAdmin.getRSGroupOfServer(Address.fromParts("bogus",123))); + assertNull(rsGroupAdmin.getRSGroupInfo("bogus")); + + try { + rsGroupAdmin.removeRSGroup("bogus"); + fail("Expected removing bogus group to fail"); + } catch(ConstraintException ex) { + //expected + } + + try { + rsGroupAdmin.moveTables(Sets.newHashSet(TableName.valueOf("bogustable")), "bogus"); + fail("Expected move with bogus group to fail"); + } catch(ConstraintException|TableNotFoundException ex) { + //expected + } + + try { + rsGroupAdmin.moveServers(Sets.newHashSet(Address.fromParts("bogus",123)), "bogus"); + fail("Expected move with bogus group to fail"); + } catch(ConstraintException ex) { + //expected + } + + try { + admin.setBalancerRunning(true,true); + rsGroupAdmin.balanceRSGroup("bogus"); + admin.setBalancerRunning(false,true); + fail("Expected move with bogus group to fail"); + } catch(ConstraintException ex) { + //expected + } + } + + @Test + public void testNamespaceConstraint() throws Exception { + String nsName = tablePrefix+"_foo"; + String groupName = tablePrefix+"_foo"; + LOG.info("testNamespaceConstraint"); + rsGroupAdmin.addRSGroup(groupName); + assertTrue(observer.preAddRSGroupCalled); + assertTrue(observer.postAddRSGroupCalled); + + admin.createNamespace(NamespaceDescriptor.create(nsName) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, groupName) + .build()); + //test removing a referenced group + try { + rsGroupAdmin.removeRSGroup(groupName); + fail("Expected a constraint exception"); + } catch (IOException ex) { + } + //test modify group + //changing with the same name is fine + admin.modifyNamespace( + NamespaceDescriptor.create(nsName) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, groupName) + .build()); + String anotherGroup = tablePrefix+"_anotherGroup"; + rsGroupAdmin.addRSGroup(anotherGroup); + //test add non-existent group + admin.deleteNamespace(nsName); + rsGroupAdmin.removeRSGroup(groupName); + assertTrue(observer.preRemoveRSGroupCalled); + assertTrue(observer.postRemoveRSGroupCalled); + try { + admin.createNamespace(NamespaceDescriptor.create(nsName) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "foo") + .build()); + fail("Expected a constraint exception"); + } catch (IOException ex) { + } + } + + @Test + public void testGroupInfoMultiAccessing() throws Exception { + RSGroupInfoManager manager = rsGroupAdminEndpoint.getGroupInfoManager(); + RSGroupInfo defaultGroup = manager.getRSGroup("default"); + // getRSGroup updates default group's server list + // this process must not affect other threads iterating the list + Iterator
it = defaultGroup.getServers().iterator(); + manager.getRSGroup("default"); + it.next(); + } + + @Test + public void testGetRSGroupInfoCPHookCalled() throws Exception { + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); + assertTrue(observer.preGetRSGroupInfoCalled); + assertTrue(observer.postGetRSGroupInfoCalled); + } + + @Test + public void testGetRSGroupInfoOfTableCPHookCalled() throws Exception { + rsGroupAdmin.getRSGroupInfoOfTable(TableName.META_TABLE_NAME); + assertTrue(observer.preGetRSGroupInfoOfTableCalled); + assertTrue(observer.postGetRSGroupInfoOfTableCalled); + } + + @Test + public void testListRSGroupsCPHookCalled() throws Exception { + rsGroupAdmin.listRSGroups(); + assertTrue(observer.preListRSGroupsCalled); + assertTrue(observer.postListRSGroupsCalled); + } + + @Test + public void testGetRSGroupInfoOfServerCPHookCalled() throws Exception { + ServerName masterServerName = ((MiniHBaseCluster) cluster).getMaster().getServerName(); + rsGroupAdmin.getRSGroupOfServer(masterServerName.getAddress()); + assertTrue(observer.preGetRSGroupInfoOfServerCalled); + assertTrue(observer.postGetRSGroupInfoOfServerCalled); + } + + @Test + public void testFailRemoveGroup() throws IOException, InterruptedException { + int initNumGroups = rsGroupAdmin.listRSGroups().size(); + addGroup("bar", 3); + TEST_UTIL.createTable(tableName, Bytes.toBytes("f")); + rsGroupAdmin.moveTables(Sets.newHashSet(tableName), "bar"); + RSGroupInfo barGroup = rsGroupAdmin.getRSGroupInfo("bar"); + //group is not empty therefore it should fail + try { + rsGroupAdmin.removeRSGroup(barGroup.getName()); + fail("Expected remove group to fail"); + } catch(IOException e) { + } + //group cannot lose all it's servers therefore it should fail + try { + rsGroupAdmin.moveServers(barGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); + fail("Expected move servers to fail"); + } catch(IOException e) { + } + + rsGroupAdmin.moveTables(barGroup.getTables(), RSGroupInfo.DEFAULT_GROUP); + try { + rsGroupAdmin.removeRSGroup(barGroup.getName()); + fail("Expected move servers to fail"); + } catch(IOException e) { + } + + rsGroupAdmin.moveServers(barGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); + rsGroupAdmin.removeRSGroup(barGroup.getName()); + + Assert.assertEquals(initNumGroups, rsGroupAdmin.listRSGroups().size()); + } + + @Test + public void testMultiTableMove() throws Exception { + final TableName tableNameA = TableName.valueOf(tablePrefix + name.getMethodName() + "A"); + final TableName tableNameB = TableName.valueOf(tablePrefix + name.getMethodName() + "B"); + final byte[] familyNameBytes = Bytes.toBytes("f"); + String newGroupName = getGroupName(name.getMethodName()); + final RSGroupInfo newGroup = addGroup(newGroupName, 1); + + TEST_UTIL.createTable(tableNameA, familyNameBytes); + TEST_UTIL.createTable(tableNameB, familyNameBytes); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + List regionsA = getTableRegionMap().get(tableNameA); + if (regionsA == null) { + return false; + } + List regionsB = getTableRegionMap().get(tableNameB); + if (regionsB == null) { + return false; + } + return getTableRegionMap().get(tableNameA).size() >= 1 + && getTableRegionMap().get(tableNameB).size() >= 1; + } + }); + + RSGroupInfo tableGrpA = rsGroupAdmin.getRSGroupInfoOfTable(tableNameA); + assertTrue(tableGrpA.getName().equals(RSGroupInfo.DEFAULT_GROUP)); + + RSGroupInfo tableGrpB = rsGroupAdmin.getRSGroupInfoOfTable(tableNameB); + assertTrue(tableGrpB.getName().equals(RSGroupInfo.DEFAULT_GROUP)); + //change table's group + LOG.info("Moving table [" + tableNameA + "," + tableNameB + "] to " + newGroup.getName()); + rsGroupAdmin.moveTables(Sets.newHashSet(tableNameA, tableNameB), newGroup.getName()); + + //verify group change + Assert.assertEquals(newGroup.getName(), + rsGroupAdmin.getRSGroupInfoOfTable(tableNameA).getName()); + + Assert.assertEquals(newGroup.getName(), + rsGroupAdmin.getRSGroupInfoOfTable(tableNameB).getName()); + + //verify tables' not exist in old group + Set DefaultTables = + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getTables(); + assertFalse(DefaultTables.contains(tableNameA)); + assertFalse(DefaultTables.contains(tableNameB)); + + //verify tables' exist in new group + Set newGroupTables = rsGroupAdmin.getRSGroupInfo(newGroupName).getTables(); + assertTrue(newGroupTables.contains(tableNameA)); + assertTrue(newGroupTables.contains(tableNameB)); + } + + @Test + public void testTableMoveTruncateAndDrop() throws Exception { + final byte[] familyNameBytes = Bytes.toBytes("f"); + String newGroupName = getGroupName(name.getMethodName()); + final RSGroupInfo newGroup = addGroup(newGroupName, 2); + + TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 5); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + List regions = getTableRegionMap().get(tableName); + if (regions == null) { + return false; + } + + return getTableRegionMap().get(tableName).size() >= 5; + } + }); + + RSGroupInfo tableGrp = rsGroupAdmin.getRSGroupInfoOfTable(tableName); + assertTrue(tableGrp.getName().equals(RSGroupInfo.DEFAULT_GROUP)); + + //change table's group + LOG.info("Moving table "+tableName+" to "+newGroup.getName()); + rsGroupAdmin.moveTables(Sets.newHashSet(tableName), newGroup.getName()); + + //verify group change + Assert.assertEquals(newGroup.getName(), + rsGroupAdmin.getRSGroupInfoOfTable(tableName).getName()); + + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + Map> serverMap = getTableServerRegionMap().get(tableName); + int count = 0; + if (serverMap != null) { + for (ServerName rs : serverMap.keySet()) { + if (newGroup.containsServer(rs.getAddress())) { + count += serverMap.get(rs).size(); + } + } + } + return count == 5; + } + }); + + //test truncate + admin.disableTable(tableName); + admin.truncateTable(tableName, true); + Assert.assertEquals(1, rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables().size()); + Assert.assertEquals(tableName, rsGroupAdmin.getRSGroupInfo( + newGroup.getName()).getTables().first()); + + //verify removed table is removed from group + TEST_UTIL.deleteTable(tableName); + Assert.assertEquals(0, rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables().size()); + + assertTrue(observer.preMoveTablesCalled); + assertTrue(observer.postMoveTablesCalled); + } + + @Test + public void testDisabledTableMove() throws Exception { + final byte[] familyNameBytes = Bytes.toBytes("f"); + String newGroupName = getGroupName(name.getMethodName()); + final RSGroupInfo newGroup = addGroup(newGroupName, 2); + + TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 5); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + List regions = getTableRegionMap().get(tableName); + if (regions == null) { + return false; + } + return getTableRegionMap().get(tableName).size() >= 5; + } + }); + + RSGroupInfo tableGrp = rsGroupAdmin.getRSGroupInfoOfTable(tableName); + assertTrue(tableGrp.getName().equals(RSGroupInfo.DEFAULT_GROUP)); + + //test disable table + admin.disableTable(tableName); + + //change table's group + LOG.info("Moving table "+ tableName + " to " + newGroup.getName()); + rsGroupAdmin.moveTables(Sets.newHashSet(tableName), newGroup.getName()); + + //verify group change + Assert.assertEquals(newGroup.getName(), + rsGroupAdmin.getRSGroupInfoOfTable(tableName).getName()); + } + + @Test + public void testNonExistentTableMove() throws Exception { + TableName tableName = TableName.valueOf(tablePrefix + name.getMethodName()); + + RSGroupInfo tableGrp = rsGroupAdmin.getRSGroupInfoOfTable(tableName); + assertNull(tableGrp); + + //test if table exists already. + boolean exist = admin.tableExists(tableName); + assertFalse(exist); + + LOG.info("Moving table "+ tableName + " to " + RSGroupInfo.DEFAULT_GROUP); + try { + rsGroupAdmin.moveTables(Sets.newHashSet(tableName), RSGroupInfo.DEFAULT_GROUP); + fail("Table " + tableName + " shouldn't have been successfully moved."); + } catch(IOException ex) { + assertTrue(ex instanceof TableNotFoundException); + } + + try { + rsGroupAdmin.moveServersAndTables( + Sets.newHashSet(Address.fromParts("bogus",123)), + Sets.newHashSet(tableName), RSGroupInfo.DEFAULT_GROUP); + fail("Table " + tableName + " shouldn't have been successfully moved."); + } catch(IOException ex) { + assertTrue(ex instanceof TableNotFoundException); + } + //verify group change + assertNull(rsGroupAdmin.getRSGroupInfoOfTable(tableName)); + } + + @Test + public void testRSGroupListDoesNotContainFailedTableCreation() throws Exception { + toggleQuotaCheckAndRestartMiniCluster(true); + String nsp = "np1"; + NamespaceDescriptor nspDesc = + NamespaceDescriptor.create(nsp) + .addConfiguration(TableNamespaceManager.KEY_MAX_REGIONS, "5") + .addConfiguration(TableNamespaceManager.KEY_MAX_TABLES, "2").build(); + admin.createNamespace(nspDesc); + assertEquals(3, admin.listNamespaceDescriptors().length); + HColumnDescriptor fam1 = new HColumnDescriptor("fam1"); + HTableDescriptor tableDescOne = + new HTableDescriptor(TableName.valueOf(nsp + TableName.NAMESPACE_DELIM + "table1")); + tableDescOne.addFamily(fam1); + admin.createTable(tableDescOne); + + HTableDescriptor tableDescTwo = + new HTableDescriptor(TableName.valueOf(nsp + TableName.NAMESPACE_DELIM + "table2")); + tableDescTwo.addFamily(fam1); + boolean constraintViolated = false; + + try { + admin.createTable(tableDescTwo, Bytes.toBytes("AAA"), Bytes.toBytes("ZZZ"), + 6); + Assert.fail("Creation table should fail because of quota violation."); + } catch (Exception exp) { + assertTrue(exp instanceof IOException); + constraintViolated = true; + } finally { + assertTrue("Constraint not violated for table " + tableDescTwo.getTableName(), + constraintViolated); + } + List rsGroupInfoList = rsGroupAdmin.listRSGroups(); + boolean foundTable2 = false; + boolean foundTable1 = false; + for(int i = 0; i < rsGroupInfoList.size(); i++){ + if(rsGroupInfoList.get(i).getTables().contains(tableDescTwo.getTableName())){ + foundTable2 = true; + } + if(rsGroupInfoList.get(i).getTables().contains(tableDescOne.getTableName())){ + foundTable1 = true; + } + } + assertFalse("Found table2 in rsgroup list.", foundTable2); + assertTrue("Did not find table1 in rsgroup list", foundTable1); + + TEST_UTIL.deleteTable(tableDescOne.getTableName()); + admin.deleteNamespace(nspDesc.getName()); + toggleQuotaCheckAndRestartMiniCluster(false); + + } + + private void toggleQuotaCheckAndRestartMiniCluster(boolean enable) throws Exception{ + TEST_UTIL.shutdownMiniCluster(); + TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, enable); + TEST_UTIL.startMiniCluster(NUM_SLAVES_BASE - 1); + TEST_UTIL.getConfiguration().setInt( + ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, + NUM_SLAVES_BASE - 1); + TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); + initialize(); + } +} diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsAdmin2.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsAdmin2.java new file mode 100644 index 000000000000..f64e507c6f4f --- /dev/null +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsAdmin2.java @@ -0,0 +1,487 @@ +/** + * 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.rsgroup; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.EnumSet; +import java.util.Iterator; +import java.util.List; +import java.util.Map; +import java.util.Set; + +import org.apache.hadoop.hbase.ClusterMetrics.Option; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.Waiter; +import org.apache.hadoop.hbase.client.ClusterConnection; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.constraint.ConstraintException; +import org.apache.hadoop.hbase.net.Address; +import org.apache.hadoop.hbase.util.Bytes; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; +import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; +import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetServerInfoRequest; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hbase.thirdparty.com.google.common.collect.Sets; + +@Category({MediumTests.class}) +public class TestRSGroupsAdmin2 extends TestRSGroupsBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRSGroupsAdmin2.class); + + protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroupsAdmin2.class); + + @BeforeClass + public static void setUp() throws Exception { + setUpTestBeforeClass(); + } + + @AfterClass + public static void tearDown() throws Exception { + tearDownAfterClass(); + } + + @Before + public void beforeMethod() throws Exception { + setUpBeforeMethod(); + } + + @After + public void afterMethod() throws Exception { + tearDownAfterMethod(); + } + + @Test + public void testRegionMove() throws Exception { + final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 1); + final byte[] familyNameBytes = Bytes.toBytes("f"); + // All the regions created below will be assigned to the default group. + TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 6); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + List regions = getTableRegionMap().get(tableName); + if (regions == null) { + return false; + } + + return getTableRegionMap().get(tableName).size() >= 6; + } + }); + + //get target region to move + Map> assignMap = + getTableServerRegionMap().get(tableName); + String targetRegion = null; + for(ServerName server : assignMap.keySet()) { + targetRegion = assignMap.get(server).size() > 0 ? assignMap.get(server).get(0) : null; + if(targetRegion != null) { + break; + } + } + //get server which is not a member of new group + ServerName targetServer = null; + for (ServerName server : admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)) + .getLiveServerMetrics().keySet()) { + if (!newGroup.containsServer(server.getAddress())) { + targetServer = server; + break; + } + } + + final AdminProtos.AdminService.BlockingInterface targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + + //move target server to group + rsGroupAdmin.moveServers(Sets.newHashSet(targetServer.getAddress()), + newGroup.getName()); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return ProtobufUtil.getOnlineRegions(targetRS).size() <= 0; + } + }); + + // Lets move this region to the new group. + TEST_UTIL.getAdmin().move(Bytes.toBytes(RegionInfo.encodeRegionName( + Bytes.toBytes(targetRegion))), Bytes.toBytes(targetServer.getServerName())); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return + getTableRegionMap().get(tableName) != null && + getTableRegionMap().get(tableName).size() == 6 && + admin.getClusterMetrics(EnumSet.of(Option.REGIONS_IN_TRANSITION)) + .getRegionStatesInTransition().size() < 1; + } + }); + + //verify that targetServer didn't open it + for (RegionInfo region: ProtobufUtil.getOnlineRegions(targetRS)) { + if (targetRegion.equals(region.getRegionNameAsString())) { + fail("Target server opened region"); + } + } + } + + @Test + public void testRegionServerMove() throws IOException, + InterruptedException { + int initNumGroups = rsGroupAdmin.listRSGroups().size(); + RSGroupInfo appInfo = addGroup(getGroupName(name.getMethodName()), 1); + RSGroupInfo adminInfo = addGroup(getGroupName(name.getMethodName()), 1); + RSGroupInfo dInfo = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); + Assert.assertEquals(initNumGroups + 2, rsGroupAdmin.listRSGroups().size()); + assertEquals(1, adminInfo.getServers().size()); + assertEquals(1, appInfo.getServers().size()); + assertEquals(getNumServers() - 2, dInfo.getServers().size()); + rsGroupAdmin.moveServers(appInfo.getServers(), + RSGroupInfo.DEFAULT_GROUP); + rsGroupAdmin.removeRSGroup(appInfo.getName()); + rsGroupAdmin.moveServers(adminInfo.getServers(), + RSGroupInfo.DEFAULT_GROUP); + rsGroupAdmin.removeRSGroup(adminInfo.getName()); + Assert.assertEquals(rsGroupAdmin.listRSGroups().size(), initNumGroups); + } + + @Test + public void testMoveServers() throws Exception { + //create groups and assign servers + addGroup("bar", 3); + rsGroupAdmin.addRSGroup("foo"); + + RSGroupInfo barGroup = rsGroupAdmin.getRSGroupInfo("bar"); + RSGroupInfo fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); + assertEquals(3, barGroup.getServers().size()); + assertEquals(0, fooGroup.getServers().size()); + + //test fail bogus server move + try { + rsGroupAdmin.moveServers(Sets.newHashSet(Address.fromString("foo:9999")),"foo"); + fail("Bogus servers shouldn't have been successfully moved."); + } catch(IOException ex) { + String exp = "Source RSGroup for server foo:9999 does not exist."; + String msg = "Expected '"+exp+"' in exception message: "; + assertTrue(msg+" "+ex.getMessage(), ex.getMessage().contains(exp)); + } + + //test success case + LOG.info("moving servers "+barGroup.getServers()+" to group foo"); + rsGroupAdmin.moveServers(barGroup.getServers(), fooGroup.getName()); + + barGroup = rsGroupAdmin.getRSGroupInfo("bar"); + fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); + assertEquals(0,barGroup.getServers().size()); + assertEquals(3,fooGroup.getServers().size()); + + LOG.info("moving servers "+fooGroup.getServers()+" to group default"); + rsGroupAdmin.moveServers(fooGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); + + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getNumServers() == + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size(); + } + }); + + fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); + assertEquals(0,fooGroup.getServers().size()); + + //test group removal + LOG.info("Remove group "+barGroup.getName()); + rsGroupAdmin.removeRSGroup(barGroup.getName()); + Assert.assertEquals(null, rsGroupAdmin.getRSGroupInfo(barGroup.getName())); + LOG.info("Remove group "+fooGroup.getName()); + rsGroupAdmin.removeRSGroup(fooGroup.getName()); + Assert.assertEquals(null, rsGroupAdmin.getRSGroupInfo(fooGroup.getName())); + } + + @Test + public void testRemoveServers() throws Exception { + LOG.info("testRemoveServers"); + final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 3); + Iterator
iterator = newGroup.getServers().iterator(); + ServerName targetServer = ServerName.parseServerName(iterator.next().toString()); + + // remove online servers + try { + rsGroupAdmin.removeServers(Sets.newHashSet(targetServer.getAddress())); + fail("Online servers shouldn't have been successfully removed."); + } catch(IOException ex) { + String exp = "Server " + targetServer.getAddress() + + " is an online server, not allowed to remove."; + String msg = "Expected '" + exp + "' in exception message: "; + assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + } + assertTrue(newGroup.getServers().contains(targetServer.getAddress())); + + // remove dead servers + NUM_DEAD_SERVERS = cluster.getClusterMetrics().getDeadServerNames().size(); + AdminProtos.AdminService.BlockingInterface targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + try { + targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, + GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); + //stopping may cause an exception + //due to the connection loss + LOG.info("stopping server " + targetServer.getServerName()); + targetRS.stopServer(null, + AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); + NUM_DEAD_SERVERS ++; + } catch(Exception e) { + } + + //wait for stopped regionserver to dead server list + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return !master.getServerManager().areDeadServersInProgress() + && cluster.getClusterMetrics().getDeadServerNames().size() == NUM_DEAD_SERVERS; + } + }); + + try { + rsGroupAdmin.removeServers(Sets.newHashSet(targetServer.getAddress())); + fail("Dead servers shouldn't have been successfully removed."); + } catch(IOException ex) { + String exp = "Server " + targetServer.getAddress() + " is on the dead servers list," + + " Maybe it will come back again, not allowed to remove."; + String msg = "Expected '" + exp + "' in exception message: "; + assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + } + assertTrue(newGroup.getServers().contains(targetServer.getAddress())); + + // remove decommissioned servers + List serversToDecommission = new ArrayList<>(); + targetServer = ServerName.parseServerName(iterator.next().toString()); + targetRS = ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, + GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); + assertTrue(master.getServerManager().getOnlineServers().containsKey(targetServer)); + serversToDecommission.add(targetServer); + + admin.decommissionRegionServers(serversToDecommission, true); + assertEquals(1, admin.listDecommissionedRegionServers().size()); + + assertTrue(newGroup.getServers().contains(targetServer.getAddress())); + rsGroupAdmin.removeServers(Sets.newHashSet(targetServer.getAddress())); + Set
newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers(); + assertFalse(newGroupServers.contains(targetServer.getAddress())); + assertEquals(2, newGroupServers.size()); + + assertTrue(observer.preRemoveServersCalled); + assertTrue(observer.postRemoveServersCalled); + } + + @Test + public void testMoveServersAndTables() throws Exception { + LOG.info("testMoveServersAndTables"); + final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 1); + //create table + final byte[] familyNameBytes = Bytes.toBytes("f"); + TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 5); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + List regions = getTableRegionMap().get(tableName); + if (regions == null) { + return false; + } + + return getTableRegionMap().get(tableName).size() >= 5; + } + }); + + //get server which is not a member of new group + ServerName targetServer = null; + for(ServerName server : admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)) + .getLiveServerMetrics().keySet()) { + if(!newGroup.containsServer(server.getAddress()) && + !rsGroupAdmin.getRSGroupInfo("master").containsServer(server.getAddress())) { + targetServer = server; + break; + } + } + + LOG.debug("Print group info : " + rsGroupAdmin.listRSGroups()); + int oldDefaultGroupServerSize = + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size(); + int oldDefaultGroupTableSize = + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getTables().size(); + + //test fail bogus server move + try { + rsGroupAdmin.moveServersAndTables(Sets.newHashSet(Address.fromString("foo:9999")), + Sets.newHashSet(tableName), newGroup.getName()); + fail("Bogus servers shouldn't have been successfully moved."); + } catch(IOException ex) { + String exp = "Source RSGroup for server foo:9999 does not exist."; + String msg = "Expected '" + exp + "' in exception message: "; + assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + } + + //test fail server move + try { + rsGroupAdmin.moveServersAndTables(Sets.newHashSet(targetServer.getAddress()), + Sets.newHashSet(tableName), RSGroupInfo.DEFAULT_GROUP); + fail("servers shouldn't have been successfully moved."); + } catch(IOException ex) { + String exp = "Target RSGroup " + RSGroupInfo.DEFAULT_GROUP + + " is same as source " + RSGroupInfo.DEFAULT_GROUP + " RSGroup."; + String msg = "Expected '" + exp + "' in exception message: "; + assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + } + + //verify default group info + Assert.assertEquals(oldDefaultGroupServerSize, + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size()); + Assert.assertEquals(oldDefaultGroupTableSize, + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getTables().size()); + + //verify new group info + Assert.assertEquals(1, + rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers().size()); + Assert.assertEquals(0, + rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables().size()); + + //get all region to move targetServer + List regionList = getTableRegionMap().get(tableName); + for(String region : regionList) { + // Lets move this region to the targetServer + TEST_UTIL.getAdmin().move(Bytes.toBytes(RegionInfo.encodeRegionName(Bytes.toBytes(region))), + Bytes.toBytes(targetServer.getServerName())); + } + + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getTableRegionMap().get(tableName) != null && + getTableRegionMap().get(tableName).size() == 5 && + getTableServerRegionMap().get(tableName).size() == 1 && + admin.getClusterMetrics(EnumSet.of(Option.REGIONS_IN_TRANSITION)) + .getRegionStatesInTransition().size() < 1; + } + }); + + //verify that all region move to targetServer + Assert.assertEquals(5, getTableServerRegionMap().get(tableName).get(targetServer).size()); + + //move targetServer and table to newGroup + LOG.info("moving server and table to newGroup"); + rsGroupAdmin.moveServersAndTables(Sets.newHashSet(targetServer.getAddress()), + Sets.newHashSet(tableName), newGroup.getName()); + + //verify group change + Assert.assertEquals(newGroup.getName(), + rsGroupAdmin.getRSGroupInfoOfTable(tableName).getName()); + + //verify servers' not exist in old group + Set
defaultServers = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP) + .getServers(); + assertFalse(defaultServers.contains(targetServer.getAddress())); + + //verify servers' exist in new group + Set
newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers(); + assertTrue(newGroupServers.contains(targetServer.getAddress())); + + //verify tables' not exist in old group + Set defaultTables = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP) + .getTables(); + assertFalse(defaultTables.contains(tableName)); + + //verify tables' exist in new group + Set newGroupTables = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables(); + assertTrue(newGroupTables.contains(tableName)); + + //verify that all region still assgin on targetServer + Assert.assertEquals(5, getTableServerRegionMap().get(tableName).get(targetServer).size()); + + assertTrue(observer.preMoveServersAndTables); + assertTrue(observer.postMoveServersAndTables); + } + + @Test + public void testMoveServersFromDefaultGroup() throws Exception { + //create groups and assign servers + rsGroupAdmin.addRSGroup("foo"); + + RSGroupInfo fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); + assertEquals(0, fooGroup.getServers().size()); + RSGroupInfo defaultGroup = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); + + //test remove all servers from default + try { + rsGroupAdmin.moveServers(defaultGroup.getServers(), fooGroup.getName()); + fail(RSGroupAdminServer.KEEP_ONE_SERVER_IN_DEFAULT_ERROR_MESSAGE); + } catch (ConstraintException ex) { + assertTrue(ex.getMessage().contains(RSGroupAdminServer + .KEEP_ONE_SERVER_IN_DEFAULT_ERROR_MESSAGE)); + } + + //test success case, remove one server from default ,keep at least one server + if (defaultGroup.getServers().size() > 1) { + Address serverInDefaultGroup = defaultGroup.getServers().iterator().next(); + LOG.info("moving server " + serverInDefaultGroup + " from group default to group " + + fooGroup.getName()); + rsGroupAdmin.moveServers(Sets.newHashSet(serverInDefaultGroup), fooGroup.getName()); + } + + fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); + LOG.info("moving servers " + fooGroup.getServers() + " to group default"); + rsGroupAdmin.moveServers(fooGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); + + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getNumServers() == + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size(); + } + }); + + fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); + assertEquals(0, fooGroup.getServers().size()); + + //test group removal + LOG.info("Remove group " + fooGroup.getName()); + rsGroupAdmin.removeRSGroup(fooGroup.getName()); + Assert.assertEquals(null, rsGroupAdmin.getRSGroupInfo(fooGroup.getName())); + } + +} diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBalance.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBalance.java new file mode 100644 index 000000000000..6cb6c81e7e02 --- /dev/null +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBalance.java @@ -0,0 +1,188 @@ +/** + * 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.rsgroup; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; + +import java.util.List; +import java.util.Map; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HColumnDescriptor; +import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.NamespaceDescriptor; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.Waiter; +import org.apache.hadoop.hbase.Waiter.Predicate; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.util.Bytes; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hbase.thirdparty.com.google.common.collect.Sets; + +@Category({MediumTests.class}) +public class TestRSGroupsBalance extends TestRSGroupsBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRSGroupsBalance.class); + + protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroupsBalance.class); + + @BeforeClass + public static void setUp() throws Exception { + setUpTestBeforeClass(); + } + + @AfterClass + public static void tearDown() throws Exception { + tearDownAfterClass(); + } + + @Before + public void beforeMethod() throws Exception { + setUpBeforeMethod(); + } + + @After + public void afterMethod() throws Exception { + tearDownAfterMethod(); + } + + @Test + public void testGroupBalance() throws Exception { + LOG.info(name.getMethodName()); + String newGroupName = getGroupName(name.getMethodName()); + final RSGroupInfo newGroup = addGroup(newGroupName, 3); + + final TableName tableName = TableName.valueOf(tablePrefix+"_ns", name.getMethodName()); + admin.createNamespace( + NamespaceDescriptor.create(tableName.getNamespaceAsString()) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, newGroupName).build()); + final byte[] familyNameBytes = Bytes.toBytes("f"); + final HTableDescriptor desc = new HTableDescriptor(tableName); + desc.addFamily(new HColumnDescriptor("f")); + byte [] startKey = Bytes.toBytes("aaaaa"); + byte [] endKey = Bytes.toBytes("zzzzz"); + admin.createTable(desc, startKey, endKey, 6); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + List regions = getTableRegionMap().get(tableName); + if (regions == null) { + return false; + } + return regions.size() >= 6; + } + }); + + //make assignment uneven, move all regions to one server + Map> assignMap = + getTableServerRegionMap().get(tableName); + final ServerName first = assignMap.entrySet().iterator().next().getKey(); + for(RegionInfo region: admin.getTableRegions(tableName)) { + if(!assignMap.get(first).contains(region.getRegionNameAsString())) { + admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(first.getServerName())); + } + } + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + Map> map = getTableServerRegionMap().get(tableName); + if (map == null) { + return true; + } + List regions = map.get(first); + if (regions == null) { + return true; + } + return regions.size() >= 6; + } + }); + + //balance the other group and make sure it doesn't affect the new group + admin.setBalancerRunning(true,true); + rsGroupAdmin.balanceRSGroup(RSGroupInfo.DEFAULT_GROUP); + assertEquals(6, getTableServerRegionMap().get(tableName).get(first).size()); + + //disable balance, balancer will not be run and return false + admin.setBalancerRunning(false,true); + assertFalse(rsGroupAdmin.balanceRSGroup(newGroupName)); + assertEquals(6, getTableServerRegionMap().get(tableName).get(first).size()); + + //enable balance + admin.setBalancerRunning(true,true); + rsGroupAdmin.balanceRSGroup(newGroupName); + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + for (List regions : getTableServerRegionMap().get(tableName).values()) { + if (2 != regions.size()) { + return false; + } + } + return true; + } + }); + admin.setBalancerRunning(false,true); + } + + @Test + public void testMisplacedRegions() throws Exception { + final TableName tableName = TableName.valueOf(tablePrefix+"_testMisplacedRegions"); + LOG.info("testMisplacedRegions"); + + final RSGroupInfo RSGroupInfo = addGroup("testMisplacedRegions", 1); + + TEST_UTIL.createMultiRegionTable(tableName, new byte[]{'f'}, 15); + TEST_UTIL.waitUntilAllRegionsAssigned(tableName); + + rsGroupAdminEndpoint.getGroupInfoManager() + .moveTables(Sets.newHashSet(tableName), RSGroupInfo.getName()); + + admin.setBalancerRunning(true,true); + assertTrue(rsGroupAdmin.balanceRSGroup(RSGroupInfo.getName())); + admin.setBalancerRunning(false,true); + assertTrue(observer.preBalanceRSGroupCalled); + assertTrue(observer.postBalanceRSGroupCalled); + + TEST_UTIL.waitFor(60000, new Predicate() { + @Override + public boolean evaluate() throws Exception { + ServerName serverName = + ServerName.valueOf(RSGroupInfo.getServers().iterator().next().toString(), 1); + return admin.getConnection().getAdmin() + .getOnlineRegions(serverName).size() == 15; + } + }); + } + +} diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBase.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBase.java index 43099db13777..6a70b3070bb9 100644 --- a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBase.java +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBase.java @@ -17,67 +17,61 @@ */ package org.apache.hadoop.hbase.rsgroup; -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; -import static org.junit.Assert.fail; import java.io.IOException; -import java.security.SecureRandom; -import java.util.ArrayList; import java.util.EnumSet; import java.util.HashSet; -import java.util.Iterator; import java.util.LinkedList; import java.util.List; import java.util.Map; +import java.util.Optional; +import java.util.Random; import java.util.Set; import java.util.TreeMap; + import org.apache.hadoop.hbase.ClusterMetrics; import org.apache.hadoop.hbase.ClusterMetrics.Option; import org.apache.hadoop.hbase.HBaseCluster; import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.MiniHBaseCluster; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.RegionMetrics; import org.apache.hadoop.hbase.ServerMetrics; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.TableNotFoundException; import org.apache.hadoop.hbase.Waiter; import org.apache.hadoop.hbase.client.Admin; -import org.apache.hadoop.hbase.client.ClusterConnection; import org.apache.hadoop.hbase.client.RegionInfo; -import org.apache.hadoop.hbase.constraint.ConstraintException; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; +import org.apache.hadoop.hbase.coprocessor.MasterCoprocessor; +import org.apache.hadoop.hbase.coprocessor.MasterCoprocessorEnvironment; +import org.apache.hadoop.hbase.coprocessor.MasterObserver; +import org.apache.hadoop.hbase.coprocessor.ObserverContext; import org.apache.hadoop.hbase.master.HMaster; +import org.apache.hadoop.hbase.master.MasterCoprocessorHost; +import org.apache.hadoop.hbase.master.ServerManager; +import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; import org.apache.hadoop.hbase.net.Address; import org.apache.hadoop.hbase.util.Bytes; -import org.junit.Assert; -import org.junit.Before; + import org.junit.Rule; -import org.junit.Test; import org.junit.rules.TestName; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.apache.hbase.thirdparty.com.google.common.collect.Lists; import org.apache.hbase.thirdparty.com.google.common.collect.Maps; import org.apache.hbase.thirdparty.com.google.common.collect.Sets; -import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; -import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; -import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetServerInfoRequest; public abstract class TestRSGroupsBase { protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroupsBase.class); - @Rule - public TestName name = new TestName(); //shared protected final static String groupPrefix = "Group"; protected final static String tablePrefix = "Group"; - protected final static SecureRandom rand = new SecureRandom(); + protected final static Random rand = new Random(); //shared, cluster type specific protected static HBaseTestingUtility TEST_UTIL; @@ -85,26 +79,115 @@ public abstract class TestRSGroupsBase { protected static HBaseCluster cluster; protected static RSGroupAdmin rsGroupAdmin; protected static HMaster master; + protected static boolean INIT = false; + protected static RSGroupAdminEndpoint rsGroupAdminEndpoint; + protected static CPMasterObserver observer; public final static long WAIT_TIMEOUT = 60000*5; public final static int NUM_SLAVES_BASE = 4; //number of slaves for the smallest cluster public static int NUM_DEAD_SERVERS = 0; // Per test variables - TableName tableName; - @Before - public void setup() { + @Rule + public TestName name = new TestName(); + protected TableName tableName; + + public static void setUpTestBeforeClass() throws Exception { + TEST_UTIL = new HBaseTestingUtility(); + TEST_UTIL.getConfiguration().setFloat( + "hbase.master.balancer.stochastic.tableSkewCost", 6000); + TEST_UTIL.getConfiguration().set( + HConstants.HBASE_MASTER_LOADBALANCER_CLASS, + RSGroupBasedLoadBalancer.class.getName()); + TEST_UTIL.getConfiguration().set(CoprocessorHost.MASTER_COPROCESSOR_CONF_KEY, + RSGroupAdminEndpoint.class.getName() + "," + CPMasterObserver.class.getName()); + TEST_UTIL.startMiniCluster(NUM_SLAVES_BASE - 1); + TEST_UTIL.getConfiguration().setInt( + ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, + NUM_SLAVES_BASE - 1); + TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); + initialize(); + } + + protected static void initialize() throws Exception { + admin = TEST_UTIL.getAdmin(); + cluster = TEST_UTIL.getHBaseCluster(); + master = ((MiniHBaseCluster)cluster).getMaster(); + + //wait for balancer to come online + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return master.isInitialized() && + ((RSGroupBasedLoadBalancer) master.getLoadBalancer()).isOnline(); + } + }); + admin.setBalancerRunning(false,true); + rsGroupAdmin = new VerifyingRSGroupAdminClient( + new RSGroupAdminClient(TEST_UTIL.getConnection()), TEST_UTIL.getConfiguration()); + MasterCoprocessorHost host = master.getMasterCoprocessorHost(); + observer = (CPMasterObserver) host.findCoprocessor(CPMasterObserver.class.getName()); + rsGroupAdminEndpoint = (RSGroupAdminEndpoint) + host.findCoprocessor(RSGroupAdminEndpoint.class.getName()); + } + + public static void tearDownAfterClass() throws Exception { + TEST_UTIL.shutdownMiniCluster(); + } + + public void setUpBeforeMethod() throws Exception { LOG.info(name.getMethodName()); tableName = TableName.valueOf(tablePrefix + "_" + name.getMethodName()); + if (!INIT) { + INIT = true; + tearDownAfterMethod(); + } + observer.resetFlags(); } - protected RSGroupInfo addGroup(String groupName, int serverCount) + public void tearDownAfterMethod() throws Exception { + deleteTableIfNecessary(); + deleteNamespaceIfNecessary(); + deleteGroups(); + + for(ServerName sn : admin.listDecommissionedRegionServers()){ + admin.recommissionRegionServer(sn, null); + } + assertTrue(admin.listDecommissionedRegionServers().isEmpty()); + + int missing = NUM_SLAVES_BASE - getNumServers(); + LOG.info("Restoring servers: "+missing); + for(int i=0; i() { + @Override + public boolean evaluate() throws Exception { + LOG.info("Waiting for cleanup to finish " + rsGroupAdmin.listRSGroups()); + //Might be greater since moving servers back to default + //is after starting a server + + return rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size() + == NUM_SLAVES_BASE; + } + }); + } + + public RSGroupInfo addGroup(String groupName, int serverCount) throws IOException, InterruptedException { RSGroupInfo defaultInfo = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); - assertTrue(defaultInfo != null); - assertTrue(defaultInfo.getServers().size() >= serverCount); rsGroupAdmin.addRSGroup(groupName); - Set
set = new HashSet<>(); for(Address server: defaultInfo.getServers()) { if(set.size() == serverCount) { @@ -114,24 +197,23 @@ protected RSGroupInfo addGroup(String groupName, int serverCount) } rsGroupAdmin.moveServers(set, groupName); RSGroupInfo result = rsGroupAdmin.getRSGroupInfo(groupName); - assertTrue(result.getServers().size() >= serverCount); return result; } - void removeGroup(String groupName) throws IOException { - RSGroupInfo RSGroupInfo = rsGroupAdmin.getRSGroupInfo(groupName); - rsGroupAdmin.moveTables(RSGroupInfo.getTables(), RSGroupInfo.DEFAULT_GROUP); - rsGroupAdmin.moveServers(RSGroupInfo.getServers(), RSGroupInfo.DEFAULT_GROUP); + public void removeGroup(String groupName) throws IOException { + RSGroupInfo groupInfo = rsGroupAdmin.getRSGroupInfo(groupName); + rsGroupAdmin.moveTables(groupInfo.getTables(), RSGroupInfo.DEFAULT_GROUP); + rsGroupAdmin.moveServers(groupInfo.getServers(), RSGroupInfo.DEFAULT_GROUP); rsGroupAdmin.removeRSGroup(groupName); } - protected void deleteTableIfNecessary() throws IOException { - for (HTableDescriptor desc : TEST_UTIL.getAdmin().listTables(tablePrefix+".*")) { + public void deleteTableIfNecessary() throws IOException { + for (TableDescriptor desc : TEST_UTIL.getAdmin().listTables(tablePrefix+".*")) { TEST_UTIL.deleteTable(desc.getTableName()); } } - protected void deleteNamespaceIfNecessary() throws IOException { + public void deleteNamespaceIfNecessary() throws IOException { for (NamespaceDescriptor desc : TEST_UTIL.getAdmin().listNamespaceDescriptors()) { if(desc.getName().startsWith(tablePrefix)) { admin.deleteNamespace(desc.getName()); @@ -139,9 +221,8 @@ protected void deleteNamespaceIfNecessary() throws IOException { } } - protected void deleteGroups() throws IOException { - RSGroupAdmin groupAdmin = - new RSGroupAdminClient(TEST_UTIL.getConnection()); + public void deleteGroups() throws IOException { + RSGroupAdmin groupAdmin = new RSGroupAdminClient(TEST_UTIL.getConnection()); for(RSGroupInfo group: groupAdmin.listRSGroups()) { if(!group.getName().equals(RSGroupInfo.DEFAULT_GROUP)) { groupAdmin.moveTables(group.getTables(), RSGroupInfo.DEFAULT_GROUP); @@ -193,85 +274,6 @@ public Map>> getTableServerRegionMap() return map; } - @Test - public void testBogusArgs() throws Exception { - assertNull(rsGroupAdmin.getRSGroupInfoOfTable(TableName.valueOf("nonexistent"))); - assertNull(rsGroupAdmin.getRSGroupOfServer(Address.fromParts("bogus",123))); - assertNull(rsGroupAdmin.getRSGroupInfo("bogus")); - - try { - rsGroupAdmin.removeRSGroup("bogus"); - fail("Expected removing bogus group to fail"); - } catch(ConstraintException ex) { - //expected - } - - try { - rsGroupAdmin.moveTables(Sets.newHashSet(TableName.valueOf("bogustable")), "bogus"); - fail("Expected move with bogus group to fail"); - } catch(ConstraintException|TableNotFoundException ex) { - //expected - } - - try { - rsGroupAdmin.moveServers(Sets.newHashSet(Address.fromParts("bogus",123)), "bogus"); - fail("Expected move with bogus group to fail"); - } catch(ConstraintException ex) { - //expected - } - - try { - admin.setBalancerRunning(true,true); - rsGroupAdmin.balanceRSGroup("bogus"); - admin.setBalancerRunning(false,true); - fail("Expected move with bogus group to fail"); - } catch(ConstraintException ex) { - //expected - } - } - - @Test - public void testCreateMultiRegion() throws IOException { - byte[] end = {1,3,5,7,9}; - byte[] start = {0,2,4,6,8}; - byte[][] f = {Bytes.toBytes("f")}; - TEST_UTIL.createTable(tableName, f,1,start,end,10); - } - - @Test - public void testCreateAndDrop() throws Exception { - TEST_UTIL.createTable(tableName, Bytes.toBytes("cf")); - //wait for created table to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getTableRegionMap().get(tableName) != null; - } - }); - TEST_UTIL.deleteTable(tableName); - } - - - @Test - public void testSimpleRegionServerMove() throws IOException, - InterruptedException { - int initNumGroups = rsGroupAdmin.listRSGroups().size(); - RSGroupInfo appInfo = addGroup(getGroupName(name.getMethodName()), 1); - RSGroupInfo adminInfo = addGroup(getGroupName(name.getMethodName()), 1); - RSGroupInfo dInfo = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); - Assert.assertEquals(initNumGroups + 2, rsGroupAdmin.listRSGroups().size()); - assertEquals(1, adminInfo.getServers().size()); - assertEquals(1, appInfo.getServers().size()); - assertEquals(getNumServers() - 2, dInfo.getServers().size()); - rsGroupAdmin.moveServers(appInfo.getServers(), - RSGroupInfo.DEFAULT_GROUP); - rsGroupAdmin.removeRSGroup(appInfo.getName()); - rsGroupAdmin.moveServers(adminInfo.getServers(), - RSGroupInfo.DEFAULT_GROUP); - rsGroupAdmin.removeRSGroup(adminInfo.getName()); - Assert.assertEquals(rsGroupAdmin.listRSGroups().size(), initNumGroups); - } - // return the real number of region servers, excluding the master embedded region server in 2.0+ public int getNumServers() throws IOException { ClusterMetrics status = @@ -286,867 +288,197 @@ public int getNumServers() throws IOException { return count; } - @Test - public void testMoveServers() throws Exception { - //create groups and assign servers - addGroup("bar", 3); - rsGroupAdmin.addRSGroup("foo"); - - RSGroupInfo barGroup = rsGroupAdmin.getRSGroupInfo("bar"); - RSGroupInfo fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); - assertEquals(3, barGroup.getServers().size()); - assertEquals(0, fooGroup.getServers().size()); - - //test fail bogus server move - try { - rsGroupAdmin.moveServers(Sets.newHashSet(Address.fromString("foo:9999")),"foo"); - fail("Bogus servers shouldn't have been successfully moved."); - } catch(IOException ex) { - String exp = "Source RSGroup for server foo:9999 does not exist."; - String msg = "Expected '"+exp+"' in exception message: "; - assertTrue(msg+" "+ex.getMessage(), ex.getMessage().contains(exp)); - } - - //test success case - LOG.info("moving servers "+barGroup.getServers()+" to group foo"); - rsGroupAdmin.moveServers(barGroup.getServers(), fooGroup.getName()); - - barGroup = rsGroupAdmin.getRSGroupInfo("bar"); - fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); - assertEquals(0,barGroup.getServers().size()); - assertEquals(3,fooGroup.getServers().size()); - - LOG.info("moving servers "+fooGroup.getServers()+" to group default"); - rsGroupAdmin.moveServers(fooGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); - - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getNumServers() == - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size(); - } - }); - - fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); - assertEquals(0,fooGroup.getServers().size()); - - //test group removal - LOG.info("Remove group "+barGroup.getName()); - rsGroupAdmin.removeRSGroup(barGroup.getName()); - Assert.assertEquals(null, rsGroupAdmin.getRSGroupInfo(barGroup.getName())); - LOG.info("Remove group "+fooGroup.getName()); - rsGroupAdmin.removeRSGroup(fooGroup.getName()); - Assert.assertEquals(null, rsGroupAdmin.getRSGroupInfo(fooGroup.getName())); + public String getGroupName(String baseName) { + return groupPrefix+"_"+baseName+"_"+rand.nextInt(Integer.MAX_VALUE); } - @Test - public void testMoveServersFromDefaultGroup() throws Exception { - //create groups and assign servers - rsGroupAdmin.addRSGroup("foo"); - - RSGroupInfo fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); - assertEquals(0, fooGroup.getServers().size()); - RSGroupInfo defaultGroup = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); - - //test remove all servers from default - try { - rsGroupAdmin.moveServers(defaultGroup.getServers(), fooGroup.getName()); - fail(RSGroupAdminServer.KEEP_ONE_SERVER_IN_DEFAULT_ERROR_MESSAGE); - } catch (ConstraintException ex) { - assertTrue(ex.getMessage().contains(RSGroupAdminServer - .KEEP_ONE_SERVER_IN_DEFAULT_ERROR_MESSAGE)); + public static class CPMasterObserver implements MasterCoprocessor, MasterObserver { + boolean preBalanceRSGroupCalled = false; + boolean postBalanceRSGroupCalled = false; + boolean preMoveServersCalled = false; + boolean postMoveServersCalled = false; + boolean preMoveTablesCalled = false; + boolean postMoveTablesCalled = false; + boolean preAddRSGroupCalled = false; + boolean postAddRSGroupCalled = false; + boolean preRemoveRSGroupCalled = false; + boolean postRemoveRSGroupCalled = false; + boolean preRemoveServersCalled = false; + boolean postRemoveServersCalled = false; + boolean preMoveServersAndTables = false; + boolean postMoveServersAndTables = false; + boolean preGetRSGroupInfoCalled = false; + boolean postGetRSGroupInfoCalled = false; + boolean preGetRSGroupInfoOfTableCalled = false; + boolean postGetRSGroupInfoOfTableCalled = false; + boolean preListRSGroupsCalled = false; + boolean postListRSGroupsCalled = false; + boolean preGetRSGroupInfoOfServerCalled = false; + boolean postGetRSGroupInfoOfServerCalled = false; + + public void resetFlags() { + preBalanceRSGroupCalled = false; + postBalanceRSGroupCalled = false; + preMoveServersCalled = false; + postMoveServersCalled = false; + preMoveTablesCalled = false; + postMoveTablesCalled = false; + preAddRSGroupCalled = false; + postAddRSGroupCalled = false; + preRemoveRSGroupCalled = false; + postRemoveRSGroupCalled = false; + preRemoveServersCalled = false; + postRemoveServersCalled = false; + preMoveServersAndTables = false; + postMoveServersAndTables = false; + preGetRSGroupInfoCalled = false; + postGetRSGroupInfoCalled = false; + preGetRSGroupInfoOfTableCalled = false; + postGetRSGroupInfoOfTableCalled = false; + preListRSGroupsCalled = false; + postListRSGroupsCalled = false; + preGetRSGroupInfoOfServerCalled = false; + postGetRSGroupInfoOfServerCalled = false; + } + + @Override + public Optional getMasterObserver() { + return Optional.of(this); } - //test success case, remove one server from default ,keep at least one server - if (defaultGroup.getServers().size() > 1) { - Address serverInDefaultGroup = defaultGroup.getServers().iterator().next(); - LOG.info("moving server " + serverInDefaultGroup + " from group default to group " + - fooGroup.getName()); - rsGroupAdmin.moveServers(Sets.newHashSet(serverInDefaultGroup), fooGroup.getName()); + @Override + public void preMoveServersAndTables(final ObserverContext ctx, + Set
servers, Set tables, String targetGroup) throws IOException { + preMoveServersAndTables = true; } - fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); - LOG.info("moving servers " + fooGroup.getServers() + " to group default"); - rsGroupAdmin.moveServers(fooGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); - - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getNumServers() == - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size(); - } - }); - - fooGroup = rsGroupAdmin.getRSGroupInfo("foo"); - assertEquals(0, fooGroup.getServers().size()); - - //test group removal - LOG.info("Remove group " + fooGroup.getName()); - rsGroupAdmin.removeRSGroup(fooGroup.getName()); - Assert.assertEquals(null, rsGroupAdmin.getRSGroupInfo(fooGroup.getName())); - } - - @Test - public void testTableMoveTruncateAndDrop() throws Exception { - final byte[] familyNameBytes = Bytes.toBytes("f"); - String newGroupName = getGroupName(name.getMethodName()); - final RSGroupInfo newGroup = addGroup(newGroupName, 2); - - TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 5); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - List regions = getTableRegionMap().get(tableName); - if (regions == null) { - return false; - } - - return getTableRegionMap().get(tableName).size() >= 5; - } - }); - - RSGroupInfo tableGrp = rsGroupAdmin.getRSGroupInfoOfTable(tableName); - assertTrue(tableGrp.getName().equals(RSGroupInfo.DEFAULT_GROUP)); - - //change table's group - LOG.info("Moving table "+tableName+" to "+newGroup.getName()); - rsGroupAdmin.moveTables(Sets.newHashSet(tableName), newGroup.getName()); - - //verify group change - Assert.assertEquals(newGroup.getName(), - rsGroupAdmin.getRSGroupInfoOfTable(tableName).getName()); - - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - Map> serverMap = getTableServerRegionMap().get(tableName); - int count = 0; - if (serverMap != null) { - for (ServerName rs : serverMap.keySet()) { - if (newGroup.containsServer(rs.getAddress())) { - count += serverMap.get(rs).size(); - } - } - } - return count == 5; - } - }); - - //test truncate - admin.disableTable(tableName); - admin.truncateTable(tableName, true); - Assert.assertEquals(1, rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables().size()); - Assert.assertEquals(tableName, rsGroupAdmin.getRSGroupInfo( - newGroup.getName()).getTables().first()); - - //verify removed table is removed from group - TEST_UTIL.deleteTable(tableName); - Assert.assertEquals(0, rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables().size()); - } - - @Test - public void testGroupBalance() throws Exception { - LOG.info(name.getMethodName()); - String newGroupName = getGroupName(name.getMethodName()); - final RSGroupInfo newGroup = addGroup(newGroupName, 3); - - final TableName tableName = TableName.valueOf(tablePrefix+"_ns", name.getMethodName()); - admin.createNamespace( - NamespaceDescriptor.create(tableName.getNamespaceAsString()) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, newGroupName).build()); - final byte[] familyNameBytes = Bytes.toBytes("f"); - final HTableDescriptor desc = new HTableDescriptor(tableName); - desc.addFamily(new HColumnDescriptor("f")); - byte [] startKey = Bytes.toBytes("aaaaa"); - byte [] endKey = Bytes.toBytes("zzzzz"); - admin.createTable(desc, startKey, endKey, 6); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - List regions = getTableRegionMap().get(tableName); - if (regions == null) { - return false; - } - return regions.size() >= 6; - } - }); - - //make assignment uneven, move all regions to one server - Map> assignMap = - getTableServerRegionMap().get(tableName); - final ServerName first = assignMap.entrySet().iterator().next().getKey(); - for(RegionInfo region: admin.getTableRegions(tableName)) { - if(!assignMap.get(first).contains(region.getRegionNameAsString())) { - admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(first.getServerName())); - } + @Override + public void postMoveServersAndTables(final ObserverContext ctx, + Set
servers, Set tables, String targetGroup) throws IOException { + postMoveServersAndTables = true; } - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - Map> map = getTableServerRegionMap().get(tableName); - if (map == null) { - return true; - } - List regions = map.get(first); - if (regions == null) { - return true; - } - return regions.size() >= 6; - } - }); - - //balance the other group and make sure it doesn't affect the new group - admin.setBalancerRunning(true,true); - rsGroupAdmin.balanceRSGroup(RSGroupInfo.DEFAULT_GROUP); - assertEquals(6, getTableServerRegionMap().get(tableName).get(first).size()); - - //disable balance, balancer will not be run and return false - admin.setBalancerRunning(false,true); - assertFalse(rsGroupAdmin.balanceRSGroup(newGroupName)); - assertEquals(6, getTableServerRegionMap().get(tableName).get(first).size()); - //enable balance - admin.setBalancerRunning(true,true); - rsGroupAdmin.balanceRSGroup(newGroupName); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - for (List regions : getTableServerRegionMap().get(tableName).values()) { - if (2 != regions.size()) { - return false; - } - } - return true; - } - }); - admin.setBalancerRunning(false,true); - } - - @Test - public void testRegionMove() throws Exception { - final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 1); - final byte[] familyNameBytes = Bytes.toBytes("f"); - // All the regions created below will be assigned to the default group. - TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 6); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - List regions = getTableRegionMap().get(tableName); - if (regions == null) { - return false; - } - - return getTableRegionMap().get(tableName).size() >= 6; - } - }); - - //get target region to move - Map> assignMap = - getTableServerRegionMap().get(tableName); - String targetRegion = null; - for(ServerName server : assignMap.keySet()) { - targetRegion = assignMap.get(server).size() > 0 ? assignMap.get(server).get(0) : null; - if(targetRegion != null) { - break; - } + @Override + public void preRemoveServers( + final ObserverContext ctx, + Set
servers) throws IOException { + preRemoveServersCalled = true; } - //get server which is not a member of new group - ServerName targetServer = null; - for (ServerName server : admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)) - .getLiveServerMetrics().keySet()) { - if (!newGroup.containsServer(server.getAddress())) { - targetServer = server; - break; - } - } - - final AdminProtos.AdminService.BlockingInterface targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - //move target server to group - rsGroupAdmin.moveServers(Sets.newHashSet(targetServer.getAddress()), - newGroup.getName()); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return ProtobufUtil.getOnlineRegions(targetRS).size() <= 0; - } - }); - - // Lets move this region to the new group. - TEST_UTIL.getAdmin().move(Bytes.toBytes(RegionInfo.encodeRegionName( - Bytes.toBytes(targetRegion))), Bytes.toBytes(targetServer.getServerName())); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return - getTableRegionMap().get(tableName) != null && - getTableRegionMap().get(tableName).size() == 6 && - admin.getClusterMetrics(EnumSet.of(Option.REGIONS_IN_TRANSITION)) - .getRegionStatesInTransition().size() < 1; - } - }); - - //verify that targetServer didn't open it - for (RegionInfo region: ProtobufUtil.getOnlineRegions(targetRS)) { - if (targetRegion.equals(region.getRegionNameAsString())) { - fail("Target server opened region"); - } + @Override + public void postRemoveServers( + final ObserverContext ctx, + Set
servers) throws IOException { + postRemoveServersCalled = true; } - } - @Test - public void testFailRemoveGroup() throws IOException, InterruptedException { - int initNumGroups = rsGroupAdmin.listRSGroups().size(); - addGroup("bar", 3); - TEST_UTIL.createTable(tableName, Bytes.toBytes("f")); - rsGroupAdmin.moveTables(Sets.newHashSet(tableName), "bar"); - RSGroupInfo barGroup = rsGroupAdmin.getRSGroupInfo("bar"); - //group is not empty therefore it should fail - try { - rsGroupAdmin.removeRSGroup(barGroup.getName()); - fail("Expected remove group to fail"); - } catch(IOException e) { - } - //group cannot lose all it's servers therefore it should fail - try { - rsGroupAdmin.moveServers(barGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); - fail("Expected move servers to fail"); - } catch(IOException e) { + @Override + public void preRemoveRSGroup(final ObserverContext ctx, + String name) throws IOException { + preRemoveRSGroupCalled = true; } - rsGroupAdmin.moveTables(barGroup.getTables(), RSGroupInfo.DEFAULT_GROUP); - try { - rsGroupAdmin.removeRSGroup(barGroup.getName()); - fail("Expected move servers to fail"); - } catch(IOException e) { + @Override + public void postRemoveRSGroup(final ObserverContext ctx, + String name) throws IOException { + postRemoveRSGroupCalled = true; } - rsGroupAdmin.moveServers(barGroup.getServers(), RSGroupInfo.DEFAULT_GROUP); - rsGroupAdmin.removeRSGroup(barGroup.getName()); - - Assert.assertEquals(initNumGroups, rsGroupAdmin.listRSGroups().size()); - } - - @Test - public void testKillRS() throws Exception { - RSGroupInfo appInfo = addGroup("appInfo", 1); - - final TableName tableName = TableName.valueOf(tablePrefix+"_ns", name.getMethodName()); - admin.createNamespace( - NamespaceDescriptor.create(tableName.getNamespaceAsString()) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, appInfo.getName()).build()); - final HTableDescriptor desc = new HTableDescriptor(tableName); - desc.addFamily(new HColumnDescriptor("f")); - admin.createTable(desc); - //wait for created table to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getTableRegionMap().get(desc.getTableName()) != null; - } - }); - - ServerName targetServer = ServerName.parseServerName( - appInfo.getServers().iterator().next().toString()); - AdminProtos.AdminService.BlockingInterface targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - RegionInfo targetRegion = ProtobufUtil.getOnlineRegions(targetRS).get(0); - Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(targetRS).size()); - - try { - //stopping may cause an exception - //due to the connection loss - targetRS.stopServer(null, - AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); - } catch(Exception e) { + @Override + public void preAddRSGroup(final ObserverContext ctx, + String name) throws IOException { + preAddRSGroupCalled = true; } - assertFalse(cluster.getClusterMetrics().getLiveServerMetrics().containsKey(targetServer)); - - //wait for created table to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return cluster.getClusterMetrics().getRegionStatesInTransition().isEmpty(); - } - }); - Set
newServers = Sets.newHashSet(); - newServers.add( - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().iterator().next()); - rsGroupAdmin.moveServers(newServers, appInfo.getName()); - - //Make sure all the table's regions get reassigned - //disabling the table guarantees no conflicting assign/unassign (ie SSH) happens - admin.disableTable(tableName); - admin.enableTable(tableName); - - //wait for region to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return cluster.getClusterMetrics().getRegionStatesInTransition().isEmpty(); - } - }); - - targetServer = ServerName.parseServerName( - newServers.iterator().next().toString()); - targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(targetRS).size()); - Assert.assertEquals(tableName, - ProtobufUtil.getOnlineRegions(targetRS).get(0).getTable()); - } - - @Test - public void testValidGroupNames() throws IOException { - String[] badNames = {"foo*","foo@","-"}; - String[] goodNames = {"foo_123"}; - for(String entry: badNames) { - try { - rsGroupAdmin.addRSGroup(entry); - fail("Expected a constraint exception for: "+entry); - } catch(ConstraintException ex) { - //expected - } + @Override + public void postAddRSGroup(final ObserverContext ctx, + String name) throws IOException { + postAddRSGroupCalled = true; } - for(String entry: goodNames) { - rsGroupAdmin.addRSGroup(entry); + @Override + public void preMoveTables(final ObserverContext ctx, + Set tables, String targetGroup) throws IOException { + preMoveTablesCalled = true; } - } - - private String getGroupName(String baseName) { - return groupPrefix+"_"+baseName+"_"+rand.nextInt(Integer.MAX_VALUE); - } - - @Test - public void testMultiTableMove() throws Exception { - final TableName tableNameA = TableName.valueOf(tablePrefix + name.getMethodName() + "A"); - final TableName tableNameB = TableName.valueOf(tablePrefix + name.getMethodName() + "B"); - final byte[] familyNameBytes = Bytes.toBytes("f"); - String newGroupName = getGroupName(name.getMethodName()); - final RSGroupInfo newGroup = addGroup(newGroupName, 1); - - TEST_UTIL.createTable(tableNameA, familyNameBytes); - TEST_UTIL.createTable(tableNameB, familyNameBytes); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - List regionsA = getTableRegionMap().get(tableNameA); - if (regionsA == null) { - return false; - } - - List regionsB = getTableRegionMap().get(tableNameB); - if (regionsB == null) { - return false; - } - - return getTableRegionMap().get(tableNameA).size() >= 1 - && getTableRegionMap().get(tableNameB).size() >= 1; - } - }); - - RSGroupInfo tableGrpA = rsGroupAdmin.getRSGroupInfoOfTable(tableNameA); - assertTrue(tableGrpA.getName().equals(RSGroupInfo.DEFAULT_GROUP)); - - RSGroupInfo tableGrpB = rsGroupAdmin.getRSGroupInfoOfTable(tableNameB); - assertTrue(tableGrpB.getName().equals(RSGroupInfo.DEFAULT_GROUP)); - //change table's group - LOG.info("Moving table [" + tableNameA + "," + tableNameB + "] to " + newGroup.getName()); - rsGroupAdmin.moveTables(Sets.newHashSet(tableNameA, tableNameB), newGroup.getName()); - - //verify group change - Assert.assertEquals(newGroup.getName(), - rsGroupAdmin.getRSGroupInfoOfTable(tableNameA).getName()); - - Assert.assertEquals(newGroup.getName(), - rsGroupAdmin.getRSGroupInfoOfTable(tableNameB).getName()); - - //verify tables' not exist in old group - Set DefaultTables = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP) - .getTables(); - assertFalse(DefaultTables.contains(tableNameA)); - assertFalse(DefaultTables.contains(tableNameB)); - - //verify tables' exist in new group - Set newGroupTables = rsGroupAdmin.getRSGroupInfo(newGroupName).getTables(); - assertTrue(newGroupTables.contains(tableNameA)); - assertTrue(newGroupTables.contains(tableNameB)); - } - - @Test - public void testDisabledTableMove() throws Exception { - final byte[] familyNameBytes = Bytes.toBytes("f"); - String newGroupName = getGroupName(name.getMethodName()); - final RSGroupInfo newGroup = addGroup(newGroupName, 2); - - TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 5); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - List regions = getTableRegionMap().get(tableName); - if (regions == null) { - return false; - } - return getTableRegionMap().get(tableName).size() >= 5; - } - }); - - RSGroupInfo tableGrp = rsGroupAdmin.getRSGroupInfoOfTable(tableName); - assertTrue(tableGrp.getName().equals(RSGroupInfo.DEFAULT_GROUP)); - //test disable table - admin.disableTable(tableName); - - //change table's group - LOG.info("Moving table "+ tableName + " to " + newGroup.getName()); - rsGroupAdmin.moveTables(Sets.newHashSet(tableName), newGroup.getName()); - - //verify group change - Assert.assertEquals(newGroup.getName(), - rsGroupAdmin.getRSGroupInfoOfTable(tableName).getName()); - } - - @Test - public void testNonExistentTableMove() throws Exception { - TableName tableName = TableName.valueOf(tablePrefix + name.getMethodName()); - - RSGroupInfo tableGrp = rsGroupAdmin.getRSGroupInfoOfTable(tableName); - assertNull(tableGrp); - - //test if table exists already. - boolean exist = admin.tableExists(tableName); - assertFalse(exist); - - LOG.info("Moving table "+ tableName + " to " + RSGroupInfo.DEFAULT_GROUP); - try { - rsGroupAdmin.moveTables(Sets.newHashSet(tableName), RSGroupInfo.DEFAULT_GROUP); - fail("Table " + tableName + " shouldn't have been successfully moved."); - } catch(IOException ex) { - assertTrue(ex instanceof TableNotFoundException); + @Override + public void postMoveTables(final ObserverContext ctx, + Set tables, String targetGroup) throws IOException { + postMoveTablesCalled = true; } - try { - rsGroupAdmin.moveServersAndTables( - Sets.newHashSet(Address.fromParts("bogus",123)), - Sets.newHashSet(tableName), RSGroupInfo.DEFAULT_GROUP); - fail("Table " + tableName + " shouldn't have been successfully moved."); - } catch(IOException ex) { - assertTrue(ex instanceof TableNotFoundException); + @Override + public void preMoveServers(final ObserverContext ctx, + Set
servers, String targetGroup) throws IOException { + preMoveServersCalled = true; } - //verify group change - assertNull(rsGroupAdmin.getRSGroupInfoOfTable(tableName)); - } - @Test - public void testMoveServersAndTables() throws Exception { - LOG.info("testMoveServersAndTables"); - final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 1); - //create table - final byte[] familyNameBytes = Bytes.toBytes("f"); - TEST_UTIL.createMultiRegionTable(tableName, familyNameBytes, 5); - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - List regions = getTableRegionMap().get(tableName); - if (regions == null) { - return false; - } - - return getTableRegionMap().get(tableName).size() >= 5; - } - }); - - //get server which is not a member of new group - ServerName targetServer = null; - for(ServerName server : admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)) - .getLiveServerMetrics().keySet()) { - if(!newGroup.containsServer(server.getAddress()) && - !rsGroupAdmin.getRSGroupInfo("master").containsServer(server.getAddress())) { - targetServer = server; - break; - } + @Override + public void postMoveServers(final ObserverContext ctx, + Set
servers, String targetGroup) throws IOException { + postMoveServersCalled = true; } - LOG.debug("Print group info : " + rsGroupAdmin.listRSGroups()); - int oldDefaultGroupServerSize = - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size(); - int oldDefaultGroupTableSize = - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getTables().size(); - - //test fail bogus server move - try { - rsGroupAdmin.moveServersAndTables(Sets.newHashSet(Address.fromString("foo:9999")), - Sets.newHashSet(tableName), newGroup.getName()); - fail("Bogus servers shouldn't have been successfully moved."); - } catch(IOException ex) { - String exp = "Source RSGroup for server foo:9999 does not exist."; - String msg = "Expected '" + exp + "' in exception message: "; - assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + @Override + public void preBalanceRSGroup(final ObserverContext ctx, + String groupName) throws IOException { + preBalanceRSGroupCalled = true; } - //test fail server move - try { - rsGroupAdmin.moveServersAndTables(Sets.newHashSet(targetServer.getAddress()), - Sets.newHashSet(tableName), RSGroupInfo.DEFAULT_GROUP); - fail("servers shouldn't have been successfully moved."); - } catch(IOException ex) { - String exp = "Target RSGroup " + RSGroupInfo.DEFAULT_GROUP + - " is same as source " + RSGroupInfo.DEFAULT_GROUP + " RSGroup."; - String msg = "Expected '" + exp + "' in exception message: "; - assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + @Override + public void postBalanceRSGroup(final ObserverContext ctx, + String groupName, boolean balancerRan) throws IOException { + postBalanceRSGroupCalled = true; } - //verify default group info - Assert.assertEquals(oldDefaultGroupServerSize, - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().size()); - Assert.assertEquals(oldDefaultGroupTableSize, - rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getTables().size()); - - //verify new group info - Assert.assertEquals(1, - rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers().size()); - Assert.assertEquals(0, - rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables().size()); - - //get all region to move targetServer - List regionList = getTableRegionMap().get(tableName); - for(String region : regionList) { - // Lets move this region to the targetServer - TEST_UTIL.getAdmin().move(Bytes.toBytes(RegionInfo.encodeRegionName(Bytes.toBytes(region))), - Bytes.toBytes(targetServer.getServerName())); + @Override + public void preGetRSGroupInfo(final ObserverContext ctx, + final String groupName) throws IOException { + preGetRSGroupInfoCalled = true; } - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return getTableRegionMap().get(tableName) != null && - getTableRegionMap().get(tableName).size() == 5 && - getTableServerRegionMap().get(tableName).size() == 1 && - admin.getClusterMetrics(EnumSet.of(Option.REGIONS_IN_TRANSITION)) - .getRegionStatesInTransition().size() < 1; - } - }); - - //verify that all region move to targetServer - Assert.assertEquals(5, getTableServerRegionMap().get(tableName).get(targetServer).size()); - - //move targetServer and table to newGroup - LOG.info("moving server and table to newGroup"); - rsGroupAdmin.moveServersAndTables(Sets.newHashSet(targetServer.getAddress()), - Sets.newHashSet(tableName), newGroup.getName()); - - //verify group change - Assert.assertEquals(newGroup.getName(), - rsGroupAdmin.getRSGroupInfoOfTable(tableName).getName()); - - //verify servers' not exist in old group - Set
defaultServers = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP) - .getServers(); - assertFalse(defaultServers.contains(targetServer.getAddress())); - - //verify servers' exist in new group - Set
newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers(); - assertTrue(newGroupServers.contains(targetServer.getAddress())); - - //verify tables' not exist in old group - Set defaultTables = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP) - .getTables(); - assertFalse(defaultTables.contains(tableName)); - - //verify tables' exist in new group - Set newGroupTables = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getTables(); - assertTrue(newGroupTables.contains(tableName)); - - //verify that all region still assgin on targetServer - Assert.assertEquals(5, getTableServerRegionMap().get(tableName).get(targetServer).size()); - } - - @Test - public void testClearDeadServers() throws Exception { - LOG.info("testClearDeadServers"); - final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 3); - NUM_DEAD_SERVERS = cluster.getClusterMetrics().getDeadServerNames().size(); - - ServerName targetServer = ServerName.parseServerName( - newGroup.getServers().iterator().next().toString()); - AdminProtos.AdminService.BlockingInterface targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - try { - targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, - GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); - //stopping may cause an exception - //due to the connection loss - targetRS.stopServer(null, - AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); - NUM_DEAD_SERVERS ++; - } catch(Exception e) { + @Override + public void postGetRSGroupInfo(final ObserverContext ctx, + final String groupName) throws IOException { + postGetRSGroupInfoCalled = true; } - //wait for stopped regionserver to dead server list - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return !master.getServerManager().areDeadServersInProgress() - && cluster.getClusterMetrics().getDeadServerNames().size() == NUM_DEAD_SERVERS; - } - }); - assertFalse(cluster.getClusterMetrics().getLiveServerMetrics().containsKey(targetServer)); - assertTrue(cluster.getClusterMetrics().getDeadServerNames().contains(targetServer)); - assertTrue(newGroup.getServers().contains(targetServer.getAddress())); - - //clear dead servers list - List notClearedServers = admin.clearDeadServers(Lists.newArrayList(targetServer)); - assertEquals(0, notClearedServers.size()); - - Set
newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers(); - assertFalse(newGroupServers.contains(targetServer.getAddress())); - assertEquals(2, newGroupServers.size()); - } - - @Test - public void testRemoveServers() throws Exception { - LOG.info("testRemoveServers"); - final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 3); - Iterator
iterator = newGroup.getServers().iterator(); - ServerName targetServer = ServerName.parseServerName(iterator.next().toString()); - // remove online servers - try { - rsGroupAdmin.removeServers(Sets.newHashSet(targetServer.getAddress())); - fail("Online servers shouldn't have been successfully removed."); - } catch(IOException ex) { - String exp = "Server " + targetServer.getAddress() - + " is an online server, not allowed to remove."; - String msg = "Expected '" + exp + "' in exception message: "; - assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + @Override + public void preGetRSGroupInfoOfTable(final ObserverContext ctx, + final TableName tableName) throws IOException { + preGetRSGroupInfoOfTableCalled = true; } - assertTrue(newGroup.getServers().contains(targetServer.getAddress())); - // remove dead servers - NUM_DEAD_SERVERS = cluster.getClusterMetrics().getDeadServerNames().size(); - AdminProtos.AdminService.BlockingInterface targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - try { - targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, - GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); - //stopping may cause an exception - //due to the connection loss - LOG.info("stopping server " + targetServer.getHostAndPort()); - targetRS.stopServer(null, - AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); - NUM_DEAD_SERVERS ++; - } catch(Exception e) { + @Override + public void postGetRSGroupInfoOfTable(final ObserverContext ctx, + final TableName tableName) throws IOException { + postGetRSGroupInfoOfTableCalled = true; } - //wait for stopped regionserver to dead server list - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return !master.getServerManager().areDeadServersInProgress() - && cluster.getClusterMetrics().getDeadServerNames().size() == NUM_DEAD_SERVERS; - } - }); - - try { - rsGroupAdmin.removeServers(Sets.newHashSet(targetServer.getAddress())); - fail("Dead servers shouldn't have been successfully removed."); - } catch(IOException ex) { - String exp = "Server " + targetServer.getAddress() + " is on the dead servers list," - + " Maybe it will come back again, not allowed to remove."; - String msg = "Expected '" + exp + "' in exception message: "; - assertTrue(msg + " " + ex.getMessage(), ex.getMessage().contains(exp)); + @Override + public void preListRSGroups(final ObserverContext ctx) + throws IOException { + preListRSGroupsCalled = true; } - assertTrue(newGroup.getServers().contains(targetServer.getAddress())); - - // remove decommissioned servers - List serversToDecommission = new ArrayList<>(); - targetServer = ServerName.parseServerName(iterator.next().toString()); - targetRS = ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, - GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); - assertTrue(master.getServerManager().getOnlineServers().containsKey(targetServer)); - serversToDecommission.add(targetServer); - - admin.decommissionRegionServers(serversToDecommission, true); - assertEquals(1, admin.listDecommissionedRegionServers().size()); - - assertTrue(newGroup.getServers().contains(targetServer.getAddress())); - rsGroupAdmin.removeServers(Sets.newHashSet(targetServer.getAddress())); - Set
newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers(); - assertFalse(newGroupServers.contains(targetServer.getAddress())); - assertEquals(2, newGroupServers.size()); - } - @Test - public void testCreateWhenRsgroupNoOnlineServers() throws Exception { - LOG.info("testCreateWhenRsgroupNoOnlineServers"); - - // set rsgroup has no online servers and test create table - final RSGroupInfo appInfo = addGroup("appInfo", 1); - Iterator
iterator = appInfo.getServers().iterator(); - List serversToDecommission = new ArrayList<>(); - ServerName targetServer = ServerName.parseServerName(iterator.next().toString()); - AdminProtos.AdminService.BlockingInterface targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - targetServer = ProtobufUtil.toServerName( - targetRS.getServerInfo(null, GetServerInfoRequest.newBuilder().build()).getServerInfo() - .getServerName()); - assertTrue(master.getServerManager().getOnlineServers().containsKey(targetServer)); - serversToDecommission.add(targetServer); - admin.decommissionRegionServers(serversToDecommission, true); - assertEquals(1, admin.listDecommissionedRegionServers().size()); + @Override + public void postListRSGroups(final ObserverContext ctx) + throws IOException { + postListRSGroupsCalled = true; + } - final TableName tableName = TableName.valueOf(tablePrefix + "_ns", name.getMethodName()); - admin.createNamespace(NamespaceDescriptor.create(tableName.getNamespaceAsString()) - .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, appInfo.getName()).build()); - final HTableDescriptor desc = new HTableDescriptor(tableName); - desc.addFamily(new HColumnDescriptor("f")); - try { - admin.createTable(desc); - fail("Shouldn't create table successfully!"); - } catch (Exception e) { - LOG.debug("create table error", e); + @Override + public void preGetRSGroupInfoOfServer(final ObserverContext ctx, + final Address server) throws IOException { + preGetRSGroupInfoOfServerCalled = true; } - // recommission and test create table - admin.recommissionRegionServer(targetServer, null); - assertEquals(0, admin.listDecommissionedRegionServers().size()); - admin.createTable(desc); - // wait for created table to be assigned - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override public boolean evaluate() throws Exception { - return getTableRegionMap().get(desc.getTableName()) != null; - } - }); - } - @Test - public void testClearNotProcessedDeadServer() throws Exception { - LOG.info("testClearNotProcessedDeadServer"); - NUM_DEAD_SERVERS = cluster.getClusterMetrics().getDeadServerNames().size(); - RSGroupInfo appInfo = addGroup("deadServerGroup", 1); - ServerName targetServer = - ServerName.parseServerName(appInfo.getServers().iterator().next().toString()); - AdminProtos.AdminService.BlockingInterface targetRS = - ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); - try { - targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, - AdminProtos.GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); - //stopping may cause an exception - //due to the connection loss - targetRS.stopServer(null, - AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); - NUM_DEAD_SERVERS ++; - } catch(Exception e) { + @Override + public void postGetRSGroupInfoOfServer(final ObserverContext ctx, + final Address server) throws IOException { + postGetRSGroupInfoOfServerCalled = true; } - TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { - @Override - public boolean evaluate() throws Exception { - return cluster.getClusterMetrics().getDeadServerNames().size() == NUM_DEAD_SERVERS; - } - }); - List notClearedServers = admin.clearDeadServers(Lists.newArrayList(targetServer)); - assertEquals(1, notClearedServers.size()); } + } diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBasics.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBasics.java new file mode 100644 index 000000000000..7415ab571195 --- /dev/null +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsBasics.java @@ -0,0 +1,320 @@ +/** + * 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.rsgroup; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Iterator; +import java.util.List; +import java.util.Set; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HColumnDescriptor; +import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.NamespaceDescriptor; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.Waiter; +import org.apache.hadoop.hbase.client.ClusterConnection; +import org.apache.hadoop.hbase.net.Address; +import org.apache.hadoop.hbase.quotas.QuotaTableUtil; +import org.apache.hadoop.hbase.quotas.QuotaUtil; +import org.apache.hadoop.hbase.util.Bytes; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; +import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; +import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetServerInfoRequest; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hbase.thirdparty.com.google.common.collect.Lists; + +@Category({MediumTests.class}) +public class TestRSGroupsBasics extends TestRSGroupsBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRSGroupsBasics.class); + + protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroupsBasics.class); + + @BeforeClass + public static void setUp() throws Exception { + setUpTestBeforeClass(); + } + + @AfterClass + public static void tearDown() throws Exception { + tearDownAfterClass(); + } + + @Before + public void beforeMethod() throws Exception { + setUpBeforeMethod(); + } + + @After + public void afterMethod() throws Exception { + tearDownAfterMethod(); + } + + @Test + public void testBasicStartUp() throws IOException { + RSGroupInfo defaultInfo = rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP); + assertEquals(4, defaultInfo.getServers().size()); + // Assignment of root and meta regions. + int count = master.getAssignmentManager().getRegionStates().getRegionAssignments().size(); + //3 meta,namespace, group + assertEquals(3, count); + } + + @Test + public void testCreateAndDrop() throws Exception { + TEST_UTIL.createTable(tableName, Bytes.toBytes("cf")); + //wait for created table to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getTableRegionMap().get(tableName) != null; + } + }); + TEST_UTIL.deleteTable(tableName); + } + + @Test + public void testCreateMultiRegion() throws IOException { + byte[] end = {1,3,5,7,9}; + byte[] start = {0,2,4,6,8}; + byte[][] f = {Bytes.toBytes("f")}; + TEST_UTIL.createTable(tableName, f,1,start,end,10); + } + + @Test + public void testNamespaceCreateAndAssign() throws Exception { + LOG.info("testNamespaceCreateAndAssign"); + String nsName = tablePrefix+"_foo"; + final TableName tableName = TableName.valueOf(nsName, tablePrefix + "_testCreateAndAssign"); + RSGroupInfo appInfo = addGroup("appInfo", 1); + admin.createNamespace(NamespaceDescriptor.create(nsName) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "appInfo").build()); + final HTableDescriptor desc = new HTableDescriptor(tableName); + desc.addFamily(new HColumnDescriptor("f")); + admin.createTable(desc); + //wait for created table to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getTableRegionMap().get(desc.getTableName()) != null; + } + }); + ServerName targetServer = + ServerName.parseServerName(appInfo.getServers().iterator().next().toString()); + AdminProtos.AdminService.BlockingInterface rs = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + //verify it was assigned to the right group + Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(rs).size()); + } + + @Test + public void testCreateWhenRsgroupNoOnlineServers() throws Exception { + LOG.info("testCreateWhenRsgroupNoOnlineServers"); + + // set rsgroup has no online servers and test create table + final RSGroupInfo appInfo = addGroup("appInfo", 1); + Iterator
iterator = appInfo.getServers().iterator(); + List serversToDecommission = new ArrayList<>(); + ServerName targetServer = ServerName.parseServerName(iterator.next().toString()); + AdminProtos.AdminService.BlockingInterface targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + targetServer = ProtobufUtil.toServerName( + targetRS.getServerInfo(null, GetServerInfoRequest.newBuilder().build()).getServerInfo() + .getServerName()); + assertTrue(master.getServerManager().getOnlineServers().containsKey(targetServer)); + serversToDecommission.add(targetServer); + admin.decommissionRegionServers(serversToDecommission, true); + assertEquals(1, admin.listDecommissionedRegionServers().size()); + + final TableName tableName = TableName.valueOf(tablePrefix + "_ns", name.getMethodName()); + admin.createNamespace(NamespaceDescriptor.create(tableName.getNamespaceAsString()) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, appInfo.getName()).build()); + final HTableDescriptor desc = new HTableDescriptor(tableName); + desc.addFamily(new HColumnDescriptor("f")); + try { + admin.createTable(desc); + fail("Shouldn't create table successfully!"); + } catch (Exception e) { + LOG.debug("create table error", e); + } + + // recommission and test create table + admin.recommissionRegionServer(targetServer, null); + assertEquals(0, admin.listDecommissionedRegionServers().size()); + admin.createTable(desc); + // wait for created table to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override public boolean evaluate() throws Exception { + return getTableRegionMap().get(desc.getTableName()) != null; + } + }); + } + + @Test + public void testDefaultNamespaceCreateAndAssign() throws Exception { + LOG.info("testDefaultNamespaceCreateAndAssign"); + String tableName = tablePrefix + "_testCreateAndAssign"; + admin.modifyNamespace(NamespaceDescriptor.create("default") + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, "default").build()); + final HTableDescriptor desc = new HTableDescriptor(TableName.valueOf(tableName)); + desc.addFamily(new HColumnDescriptor("f")); + admin.createTable(desc); + //wait for created table to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getTableRegionMap().get(desc.getTableName()) != null; + } + }); + } + + @Test + public void testCloneSnapshot() throws Exception { + byte[] FAMILY = Bytes.toBytes("test"); + String snapshotName = tableName.getNameAsString() + "_snap"; + TableName clonedTableName = TableName.valueOf(tableName.getNameAsString() + "_clone"); + + // create base table + TEST_UTIL.createTable(tableName, FAMILY); + + // create snapshot + admin.snapshot(snapshotName, tableName); + + // clone + admin.cloneSnapshot(snapshotName, clonedTableName); + } + + @Test + public void testClearDeadServers() throws Exception { + LOG.info("testClearDeadServers"); + final RSGroupInfo newGroup = addGroup(getGroupName(name.getMethodName()), 3); + NUM_DEAD_SERVERS = cluster.getClusterMetrics().getDeadServerNames().size(); + + ServerName targetServer = ServerName.parseServerName( + newGroup.getServers().iterator().next().toString()); + AdminProtos.AdminService.BlockingInterface targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + try { + targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, + GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); + //stopping may cause an exception + //due to the connection loss + targetRS.stopServer(null, + AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); + NUM_DEAD_SERVERS ++; + } catch(Exception e) { + } + //wait for stopped regionserver to dead server list + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return !master.getServerManager().areDeadServersInProgress() + && cluster.getClusterMetrics().getDeadServerNames().size() == NUM_DEAD_SERVERS; + } + }); + assertFalse(cluster.getClusterMetrics().getLiveServerMetrics().containsKey(targetServer)); + assertTrue(cluster.getClusterMetrics().getDeadServerNames().contains(targetServer)); + assertTrue(newGroup.getServers().contains(targetServer.getAddress())); + + //clear dead servers list + List notClearedServers = admin.clearDeadServers(Lists.newArrayList(targetServer)); + assertEquals(0, notClearedServers.size()); + + Set
newGroupServers = rsGroupAdmin.getRSGroupInfo(newGroup.getName()).getServers(); + assertFalse(newGroupServers.contains(targetServer.getAddress())); + assertEquals(2, newGroupServers.size()); + } + + @Test + public void testClearNotProcessedDeadServer() throws Exception { + LOG.info("testClearNotProcessedDeadServer"); + NUM_DEAD_SERVERS = cluster.getClusterMetrics().getDeadServerNames().size(); + RSGroupInfo appInfo = addGroup("deadServerGroup", 1); + ServerName targetServer = + ServerName.parseServerName(appInfo.getServers().iterator().next().toString()); + AdminProtos.AdminService.BlockingInterface targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + try { + targetServer = ProtobufUtil.toServerName(targetRS.getServerInfo(null, + AdminProtos.GetServerInfoRequest.newBuilder().build()).getServerInfo().getServerName()); + //stopping may cause an exception + //due to the connection loss + targetRS.stopServer(null, + AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); + NUM_DEAD_SERVERS ++; + } catch(Exception e) { + } + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return cluster.getClusterMetrics().getDeadServerNames().size() == NUM_DEAD_SERVERS; + } + }); + List notClearedServers = + admin.clearDeadServers(Lists.newArrayList(targetServer)); + assertEquals(1, notClearedServers.size()); + } + + @Test + public void testRSGroupsWithHBaseQuota() throws Exception { + TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, true); + restartHBaseCluster(); + try { + TEST_UTIL.waitFor(90000, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return admin.isTableAvailable(QuotaTableUtil.QUOTA_TABLE_NAME); + } + }); + } finally { + TEST_UTIL.getConfiguration().setBoolean(QuotaUtil.QUOTA_CONF_KEY, false); + restartHBaseCluster(); + } + } + + private void restartHBaseCluster() throws Exception { + LOG.info("\n\nShutting down cluster"); + TEST_UTIL.shutdownMiniHBaseCluster(); + LOG.info("\n\nSleeping a bit"); + Thread.sleep(2000); + TEST_UTIL.restartHBaseCluster(NUM_SLAVES_BASE - 1); + initialize(); + } +} diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsKillRS.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsKillRS.java new file mode 100644 index 000000000000..bce4cc9af0af --- /dev/null +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsKillRS.java @@ -0,0 +1,149 @@ +/** + * 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.rsgroup; + +import static org.junit.Assert.assertFalse; + +import java.util.Set; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HColumnDescriptor; +import org.apache.hadoop.hbase.HTableDescriptor; +import org.apache.hadoop.hbase.NamespaceDescriptor; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.Waiter; +import org.apache.hadoop.hbase.client.ClusterConnection; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.net.Address; + +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; +import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hbase.thirdparty.com.google.common.collect.Sets; + +@Category({MediumTests.class}) +public class TestRSGroupsKillRS extends TestRSGroupsBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRSGroupsKillRS.class); + + protected static final Logger LOG = LoggerFactory.getLogger(TestRSGroupsKillRS.class); + + @BeforeClass + public static void setUp() throws Exception { + setUpTestBeforeClass(); + } + + @AfterClass + public static void tearDown() throws Exception { + tearDownAfterClass(); + } + + @Before + public void beforeMethod() throws Exception { + setUpBeforeMethod(); + } + + @After + public void afterMethod() throws Exception { + tearDownAfterMethod(); + } + + @Test + public void testKillRS() throws Exception { + RSGroupInfo appInfo = addGroup("appInfo", 1); + + final TableName tableName = TableName.valueOf(tablePrefix+"_ns", name.getMethodName()); + admin.createNamespace( + NamespaceDescriptor.create(tableName.getNamespaceAsString()) + .addConfiguration(RSGroupInfo.NAMESPACE_DESC_PROP_GROUP, appInfo.getName()).build()); + final HTableDescriptor desc = new HTableDescriptor(tableName); + desc.addFamily(new HColumnDescriptor("f")); + admin.createTable(desc); + //wait for created table to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return getTableRegionMap().get(desc.getTableName()) != null; + } + }); + + ServerName targetServer = ServerName.parseServerName( + appInfo.getServers().iterator().next().toString()); + AdminProtos.AdminService.BlockingInterface targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + RegionInfo targetRegion = ProtobufUtil.getOnlineRegions(targetRS).get(0); + Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(targetRS).size()); + + try { + //stopping may cause an exception + //due to the connection loss + targetRS.stopServer(null, + AdminProtos.StopServerRequest.newBuilder().setReason("Die").build()); + } catch(Exception e) { + } + assertFalse(cluster.getClusterMetrics().getLiveServerMetrics().containsKey(targetServer)); + + //wait for created table to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return cluster.getClusterMetrics().getRegionStatesInTransition().isEmpty(); + } + }); + Set
newServers = Sets.newHashSet(); + newServers.add( + rsGroupAdmin.getRSGroupInfo(RSGroupInfo.DEFAULT_GROUP).getServers().iterator().next()); + rsGroupAdmin.moveServers(newServers, appInfo.getName()); + + //Make sure all the table's regions get reassigned + //disabling the table guarantees no conflicting assign/unassign (ie SSH) happens + admin.disableTable(tableName); + admin.enableTable(tableName); + + //wait for region to be assigned + TEST_UTIL.waitFor(WAIT_TIMEOUT, new Waiter.Predicate() { + @Override + public boolean evaluate() throws Exception { + return cluster.getClusterMetrics().getRegionStatesInTransition().isEmpty(); + } + }); + + targetServer = ServerName.parseServerName( + newServers.iterator().next().toString()); + targetRS = + ((ClusterConnection) admin.getConnection()).getAdmin(targetServer); + Assert.assertEquals(1, ProtobufUtil.getOnlineRegions(targetRS).size()); + Assert.assertEquals(tableName, + ProtobufUtil.getOnlineRegions(targetRS).get(0).getTable()); + } + +} diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java index 1d5881e2e439..b93de57bd8bb 100644 --- a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsOfflineMode.java @@ -36,6 +36,7 @@ import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; + import org.junit.AfterClass; import org.junit.Assert; import org.junit.BeforeClass; diff --git a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsWithACL.java b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsWithACL.java index a63626d99472..b6f6463ac9d7 100644 --- a/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsWithACL.java +++ b/hbase-rsgroup/src/test/java/org/apache/hadoop/hbase/rsgroup/TestRSGroupsWithACL.java @@ -41,6 +41,7 @@ import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.SecurityTests; import org.apache.hadoop.hbase.util.Bytes; + import org.junit.AfterClass; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -177,9 +178,10 @@ private static void setUpTableAndUserPermissions() throws Exception { try { assertEquals(4, AccessControlClient.getUserPermissions(systemUserConnection, TEST_TABLE.toString()).size()); + } catch (AssertionError e) { + fail(e.getMessage()); } catch (Throwable e) { LOG.error("error during call of AccessControlClient.getUserPermissions. ", e); - fail("error during call of AccessControlClient.getUserPermissions."); } } diff --git a/hbase-rsgroup/src/test/resources/log4j.properties b/hbase-rsgroup/src/test/resources/log4j.properties new file mode 100644 index 000000000000..c322699ced24 --- /dev/null +++ b/hbase-rsgroup/src/test/resources/log4j.properties @@ -0,0 +1,68 @@ +# 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. + +# Define some default values that can be overridden by system properties +hbase.root.logger=INFO,console +hbase.log.dir=. +hbase.log.file=hbase.log + +# Define the root logger to the system property "hbase.root.logger". +log4j.rootLogger=${hbase.root.logger} + +# Logging Threshold +log4j.threshold=ALL + +# +# Daily Rolling File Appender +# +log4j.appender.DRFA=org.apache.log4j.DailyRollingFileAppender +log4j.appender.DRFA.File=${hbase.log.dir}/${hbase.log.file} + +# Rollver at midnight +log4j.appender.DRFA.DatePattern=.yyyy-MM-dd + +# 30-day backup +#log4j.appender.DRFA.MaxBackupIndex=30 +log4j.appender.DRFA.layout=org.apache.log4j.PatternLayout +# Debugging Pattern format +log4j.appender.DRFA.layout.ConversionPattern=%d{ISO8601} %-5p [%t] %C{2}(%L): %m%n + + +# +# console +# Add "console" to rootlogger above if you want to use this +# +log4j.appender.console=org.apache.log4j.ConsoleAppender +log4j.appender.console.target=System.err +log4j.appender.console.layout=org.apache.log4j.PatternLayout +log4j.appender.console.layout.ConversionPattern=%d{ISO8601} %-5p [%t] %C{2}(%L): %m%n + +# Custom Logging levels + +#log4j.logger.org.apache.hadoop.fs.FSNamesystem=DEBUG + +log4j.logger.org.apache.hadoop=WARN +log4j.logger.org.apache.zookeeper=ERROR +log4j.logger.org.apache.hadoop.hbase=DEBUG + +#These settings are workarounds against spurious logs from the minicluster. +#See HBASE-4709 +log4j.logger.org.apache.hadoop.metrics2.impl.MetricsConfig=WARN +log4j.logger.org.apache.hadoop.metrics2.impl.MetricsSinkAdapter=WARN +log4j.logger.org.apache.hadoop.metrics2.impl.MetricsSystemImpl=WARN +log4j.logger.org.apache.hadoop.metrics2.util.MBeans=WARN +# Enable this to get detailed connection error/retry logging. +# log4j.logger.org.apache.hadoop.hbase.client.ConnectionImplementation=TRACE diff --git a/hbase-server/pom.xml b/hbase-server/pom.xml index 473b7409de74..54558f7f77cb 100644 --- a/hbase-server/pom.xml +++ b/hbase-server/pom.xml @@ -533,14 +533,20 @@ test - org.apache.hadoop - hadoop-minikdc + org.bouncycastle + bcprov-jdk15on test - org.bouncycastle - bcprov-jdk16 + org.apache.hadoop + hadoop-minikdc test + + + bouncycastle + bcprov-jdk15 + + org.apache.kerby diff --git a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/common/TaskMonitorTmpl.jamon b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/common/TaskMonitorTmpl.jamon index 9f27d4683046..c4dff1458f23 100644 --- a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/common/TaskMonitorTmpl.jamon +++ b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/common/TaskMonitorTmpl.jamon @@ -30,7 +30,7 @@ String format = "html"; <%if format.equals("json")%> <& renderTasks; filter=filter &> <%else> -

Tasks

+

Tasks

    diff --git a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/AssignmentManagerStatusTmpl.jamon b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/AssignmentManagerStatusTmpl.jamon index bb3686b2985a..b94ba4338e0c 100644 --- a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/AssignmentManagerStatusTmpl.jamon +++ b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/AssignmentManagerStatusTmpl.jamon @@ -49,7 +49,7 @@ int ritsPerPage = Math.min(5, numOfRITs); int numOfPages = (int) Math.ceil(numOfRITs * 1.0 / ritsPerPage);
    -

    Regions in Transition

    +

    Regions in Transition

    <% numOfRITs %> region(s) in transition. <%if ritStat.hasRegionsTwiceOverThreshold() %> diff --git a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/MasterStatusTmpl.jamon b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/MasterStatusTmpl.jamon index 4085193b7f55..3180c56fcc3e 100644 --- a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/MasterStatusTmpl.jamon +++ b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/MasterStatusTmpl.jamon @@ -44,6 +44,7 @@ org.apache.hadoop.hbase.ServerName; org.apache.hadoop.hbase.TableName; org.apache.hadoop.hbase.client.Admin; org.apache.hadoop.hbase.client.MasterSwitchType; +org.apache.hadoop.hbase.client.TableState; org.apache.hadoop.hbase.master.assignment.AssignmentManager; org.apache.hadoop.hbase.master.DeadServer; org.apache.hadoop.hbase.master.HMaster; @@ -216,12 +217,12 @@ AssignmentManager assignmentManager = master.getAssignmentManager(); <%if master.getMasterCoprocessorHost().findCoprocessor("RSGroupAdminEndpoint") != null %>

    -

    RSGroup

    +

    RSGroup

    <& RSGroupListTmpl; master= master; serverManager= serverManager&>
    -

    Region Servers

    +

    Region Servers

    <& RegionServerListTmpl; master= master; servers = servers &> <%if (deadServers != null) %> @@ -232,7 +233,7 @@ AssignmentManager assignmentManager = master.getAssignmentManager(); <& BackupMasterStatusTmpl; master = master &>
    -

    Tables

    +

    Tables

    • @@ -263,7 +264,7 @@ AssignmentManager assignmentManager = master.getAssignmentManager();
    -

    Peers

    +

    Peers

    <& peerConfigs &>
    <%if master.getAssignmentManager() != null %> @@ -281,7 +282,7 @@ AssignmentManager assignmentManager = master.getAssignmentManager();
    -

    Software Attributes

    +

    Software Attributes

    @@ -395,8 +396,22 @@ AssignmentManager assignmentManager = master.getAssignmentManager(); + + @@ -461,28 +476,42 @@ AssignmentManager assignmentManager = master.getAssignmentManager(); <%if (tables != null && tables.size() > 0)%> -
    Attribute Name
    +
    + - - + + <%if (frags != null) %> - - - - - - + + + + + + + + + + + + + + + <%for TableDescriptor desc : tables%> <%java> HTableDescriptor htDesc = new HTableDescriptor(desc); TableName tableName = htDesc.getTableName(); + TableState tableState = master.getTableStateManager().getTableState(tableName); Map> tableRegions = master.getAssignmentManager().getRegionStates() .getRegionByStateOfTable(tableName); int openRegionsCount = tableRegions.get(RegionState.State.OPEN).size(); + int openingRegionsCount = tableRegions.get(RegionState.State.OPENING).size(); + int closedRegionsCount = tableRegions.get(RegionState.State.CLOSED).size(); + int closingRegionsCount = tableRegions.get(RegionState.State.CLOSING).size(); int offlineRegionsCount = tableRegions.get(RegionState.State.OFFLINE).size(); int splitRegionsCount = tableRegions.get(RegionState.State.SPLIT).size(); int failedRegionsCount = tableRegions.get(RegionState.State.FAILED_OPEN).size() @@ -494,7 +523,8 @@ AssignmentManager assignmentManager = master.getAssignmentManager(); // now subtract known states otherRegionsCount = otherRegionsCount - openRegionsCount - failedRegionsCount - offlineRegionsCount - - splitRegionsCount; + - splitRegionsCount - openingRegionsCount + - closedRegionsCount - closingRegionsCount; @@ -502,7 +532,11 @@ AssignmentManager assignmentManager = master.getAssignmentManager(); <%if (frags != null) %> + + + + @@ -511,6 +545,7 @@ AssignmentManager assignmentManager = master.getAssignmentManager();

    <% tables.size() %> table(s) in set. [Details]

    +
    NamespaceTable NameNamespaceNameFrag. Online RegionsOffline RegionsFailed RegionsSplit RegionsOther RegionsDescriptionStateRegionsDescription
    OPENOPENINGCLOSEDCLOSINGOFFLINEFAILEDSPLITOther
    <% tableName.getNamespaceAsString() %><% frags.get(tableName.getNameAsString()) != null ? frags.get(tableName.getNameAsString()).intValue() + "%" : "n/a" %> <% tableState.getState() %> <% openRegionsCount %><% openingRegionsCount %><% closedRegionsCount %><% closingRegionsCount %> <% offlineRegionsCount %> <% failedRegionsCount %> <% splitRegionsCount %>
    diff --git a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/RegionServerListTmpl.jamon b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/RegionServerListTmpl.jamon index 67d330584bc7..0afc705c9ed2 100644 --- a/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/RegionServerListTmpl.jamon +++ b/hbase-server/src/main/jamon/org/apache/hadoop/hbase/tmpl/master/RegionServerListTmpl.jamon @@ -82,7 +82,8 @@ Arrays.sort(serverNames); <%args> ServerName [] serverNames; - +
    + @@ -91,6 +92,8 @@ Arrays.sort(serverNames); + + <%java> int totalRegions = 0; int totalRequestsPerSecond = 0; @@ -128,6 +131,7 @@ Arrays.sort(serverNames); <%java> } + @@ -146,7 +150,8 @@ Arrays.sort(serverNames); <%args> ServerName [] serverNames; -
    ServerName Start timeRequests Per Second Num. Regions
    Total:<% servers.size() %>
    +
    + @@ -154,6 +159,8 @@ Arrays.sort(serverNames); + + <%java> for (ServerName serverName: serverNames) { @@ -182,6 +189,7 @@ for (ServerName serverName: serverNames) { } } +
    ServerName Used HeapMemstore Size
    @@ -190,7 +198,8 @@ for (ServerName serverName: serverNames) { <%args> ServerName [] serverNames; - +
    + @@ -198,6 +207,8 @@ for (ServerName serverName: serverNames) { + + <%java> for (ServerName serverName: serverNames) { @@ -227,6 +238,7 @@ if (sl != null) { } } +
    ServerName Request Per SecondFiltered Read Request Count Write Request Count
    @@ -235,7 +247,8 @@ if (sl != null) { <%args> ServerName [] serverNames; - +
    + @@ -245,6 +258,8 @@ if (sl != null) { + + <%java> for (ServerName serverName: serverNames) { @@ -286,6 +301,7 @@ if (sl != null) { } } +
    ServerName Num. StoresIndex Size Bloom Size
    @@ -293,7 +309,8 @@ if (sl != null) { <%args> ServerName [] serverNames; - +
    + @@ -301,6 +318,8 @@ if (sl != null) { + + <%java> for (ServerName serverName: serverNames) { @@ -333,6 +352,7 @@ if (totalCompactingCells > 0) { } } +
    ServerName Num. Compacting CellsRemaining Cells Compaction Progress
    diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/executor/ExecutorService.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/executor/ExecutorService.java index 342d44144ae5..4f8909e62b83 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/executor/ExecutorService.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/executor/ExecutorService.java @@ -27,19 +27,22 @@ import java.util.concurrent.BlockingQueue; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.Executors; import java.util.concurrent.LinkedBlockingQueue; import java.util.concurrent.ThreadPoolExecutor; import java.util.concurrent.TimeUnit; import java.util.concurrent.atomic.AtomicLong; - +import org.apache.hadoop.hbase.monitoring.ThreadMonitoring; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.apache.hadoop.hbase.monitoring.ThreadMonitoring; import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.hbase.thirdparty.com.google.common.collect.Lists; import org.apache.hbase.thirdparty.com.google.common.collect.Maps; +import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ListenableFuture; +import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ListeningScheduledExecutorService; +import org.apache.hbase.thirdparty.com.google.common.util.concurrent.MoreExecutors; import org.apache.hbase.thirdparty.com.google.common.util.concurrent.ThreadFactoryBuilder; /** @@ -64,12 +67,15 @@ public class ExecutorService { // Name of the server hosting this executor service. private final String servername; + private final ListeningScheduledExecutorService delayedSubmitTimer = + MoreExecutors.listeningDecorator(Executors.newScheduledThreadPool(1, new ThreadFactoryBuilder() + .setDaemon(true).setNameFormat("Event-Executor-Delay-Submit-Timer").build())); + /** * Default constructor. * @param servername Name of the hosting server. */ public ExecutorService(final String servername) { - super(); this.servername = servername; } @@ -99,6 +105,7 @@ boolean isExecutorServiceRunning(String name) { } public void shutdown() { + this.delayedSubmitTimer.shutdownNow(); for(Entry entry: this.executorMap.entrySet()) { List wasRunning = entry.getValue().threadPoolExecutor.shutdownNow(); @@ -146,6 +153,18 @@ public void submit(final EventHandler eh) { } } + // Submit the handler after the given delay. Used for retrying. + public void delayedSubmit(EventHandler eh, long delay, TimeUnit unit) { + ListenableFuture future = delayedSubmitTimer.schedule(() -> submit(eh), delay, unit); + future.addListener(() -> { + try { + future.get(); + } catch (Exception e) { + LOG.error("Failed to submit the event handler {} to executor", eh, e); + } + }, MoreExecutors.directExecutor()); + } + public Map getAllExecutorStatuses() { Map ret = Maps.newHashMap(); for (Map.Entry e : executorMap.entrySet()) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CacheConfig.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CacheConfig.java index ac1af9161746..147568e19578 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CacheConfig.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CacheConfig.java @@ -48,10 +48,8 @@ public class CacheConfig { /** * Disabled cache configuration */ - public static final CacheConfig DISABLED = new CacheConfig(); - /** * Configuration key to cache data blocks on read. Bloom blocks and index blocks are always be * cached if the block cache is enabled. @@ -247,7 +245,11 @@ public CacheConfig(Configuration conf, ColumnFamilyDescriptor family) { * @param conf hbase configuration */ public CacheConfig(Configuration conf) { - this(CacheConfig.instantiateBlockCache(conf), + this(conf, true); + } + + public CacheConfig(Configuration conf, boolean enableBlockCache) { + this(conf, enableBlockCache, conf.getBoolean(CACHE_DATA_ON_READ_KEY, DEFAULT_CACHE_DATA_ON_READ), DEFAULT_IN_MEMORY, // This is a family-level setting so can't be set // strictly from conf @@ -257,11 +259,32 @@ public CacheConfig(Configuration conf) { conf.getBoolean(EVICT_BLOCKS_ON_CLOSE_KEY, DEFAULT_EVICT_ON_CLOSE), conf.getBoolean(CACHE_DATA_BLOCKS_COMPRESSED_KEY, DEFAULT_CACHE_DATA_COMPRESSED), conf.getBoolean(PREFETCH_BLOCKS_ON_OPEN_KEY, DEFAULT_PREFETCH_ON_OPEN), - conf.getBoolean(DROP_BEHIND_CACHE_COMPACTION_KEY, DROP_BEHIND_CACHE_COMPACTION_DEFAULT) - ); + conf.getBoolean(DROP_BEHIND_CACHE_COMPACTION_KEY, DROP_BEHIND_CACHE_COMPACTION_DEFAULT)); LOG.info("Created cacheConfig: " + this); } + private CacheConfig(Configuration conf, boolean enableBlockCache, + final boolean cacheDataOnRead, final boolean inMemory, + final boolean cacheDataOnWrite, final boolean cacheIndexesOnWrite, + final boolean cacheBloomsOnWrite, final boolean evictOnClose, + final boolean cacheDataCompressed, final boolean prefetchOnOpen, + final boolean dropBehindCompaction) { + if (enableBlockCache) { + this.blockCache = CacheConfig.instantiateBlockCache(conf); + } else { + this.blockCache = null; + } + this.cacheDataOnRead = cacheDataOnRead; + this.inMemory = inMemory; + this.cacheDataOnWrite = cacheDataOnWrite; + this.cacheIndexesOnWrite = cacheIndexesOnWrite; + this.cacheBloomsOnWrite = cacheBloomsOnWrite; + this.evictOnClose = evictOnClose; + this.cacheDataCompressed = cacheDataCompressed; + this.prefetchOnOpen = prefetchOnOpen; + this.dropBehindCompaction = dropBehindCompaction; + } + /** * Create a block cache configuration with the specified cache and configuration parameters. * @param blockCache reference to block cache, null if completely disabled @@ -274,11 +297,10 @@ public CacheConfig(Configuration conf) { * @param evictOnClose whether blocks should be evicted when HFile is closed * @param cacheDataCompressed whether to store blocks as compressed in the cache * @param prefetchOnOpen whether to prefetch blocks upon open - * @param cacheDataInL1 If more than one cache tier deployed, if true, cache this column families - * data blocks up in the L1 tier. * @param dropBehindCompaction indicate that we should set drop behind to true when open a store * file reader for compaction */ + @VisibleForTesting CacheConfig(final BlockCache blockCache, final boolean cacheDataOnRead, final boolean inMemory, final boolean cacheDataOnWrite, final boolean cacheIndexesOnWrite, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CompoundBloomFilterWriter.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CompoundBloomFilterWriter.java index d63a824832ef..a4a805e8c985 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CompoundBloomFilterWriter.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/io/hfile/CompoundBloomFilterWriter.java @@ -174,12 +174,12 @@ public void append(Cell cell) throws IOException { + Bytes.toStringBinary(firstKeyInChunk)); } // This will be done only once per chunk - if (bloomType == BloomType.ROW) { - firstKeyInChunk = CellUtil.copyRow(cell); - } else { + if (bloomType == BloomType.ROWCOL) { firstKeyInChunk = PrivateCellUtil .getCellKeySerializedAsKeyValueKey(PrivateCellUtil.createFirstOnRowCol(cell)); + } else { + firstKeyInChunk = CellUtil.copyRow(cell); } allocateNewChunk(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/CatalogJanitor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/CatalogJanitor.java index 85150937e917..73fabf8ca7b2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/CatalogJanitor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/CatalogJanitor.java @@ -111,14 +111,16 @@ boolean getEnabled() { protected void chore() { try { AssignmentManager am = this.services.getAssignmentManager(); - if (this.enabled.get() && !this.services.isInMaintenanceMode() && am != null && + if (this.enabled.get() && !this.services.isInMaintenanceMode() && + !this.services.getServerManager().isClusterShutdown() && am != null && am.isMetaLoaded() && !am.hasRegionsInTransition()) { scan(); } else { LOG.warn("CatalogJanitor is disabled! Enabled=" + this.enabled.get() + ", maintenanceMode=" + this.services.isInMaintenanceMode() + ", am=" + am + ", metaLoaded=" + (am != null && am.isMetaLoaded()) + ", hasRIT=" + - (am != null && am.hasRegionsInTransition())); + (am != null && am.hasRegionsInTransition()) + " clusterShutDown=" + this.services + .getServerManager().isClusterShutdown()); } } catch (IOException e) { LOG.warn("Failed scan of catalog table", e); 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 116d24e72158..4183201c614b 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 @@ -25,6 +25,8 @@ import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.util.Pair; +import com.google.common.base.Preconditions; + import java.util.ArrayList; import java.util.Collections; import java.util.Comparator; @@ -36,6 +38,7 @@ import java.util.Map; import java.util.Set; + /** * Class to hold dead servers list and utility querying dead server list. * On znode expiration, servers are added here. @@ -54,14 +57,9 @@ public class DeadServer { private final Map deadServers = new HashMap<>(); /** - * Number of dead servers currently being processed - */ - private int numProcessing = 0; - - /** - * Whether a dead server is being processed currently. + * Set of dead servers currently being processed */ - private volatile boolean processing = false; + private final Set processingServers = new HashSet(); /** * A dead server that comes back alive has a different start code. The new start code should be @@ -76,7 +74,13 @@ public synchronized boolean cleanPreviousInstance(final ServerName newServerName while (it.hasNext()) { ServerName sn = it.next(); if (ServerName.isSameAddress(sn, newServerName)) { + // remove from deadServers it.remove(); + // remove from processingServers + boolean removed = processingServers.remove(sn); + if (removed) { + LOG.debug("Removed " + sn + " ; numProcessing=" + processingServers.size()); + } return true; } } @@ -92,6 +96,14 @@ public synchronized boolean isDeadServer(final ServerName serverName) { return deadServers.containsKey(serverName); } + /** + * @param serverName server name. + * @return true if this server is on the processing servers list false otherwise + */ + public synchronized boolean isProcessingServer(final ServerName serverName) { + return processingServers.contains(serverName); + } + /** * Checks if there are currently any dead servers being processed by the * master. Returns true if at least one region server is currently being @@ -99,7 +111,9 @@ public synchronized boolean isDeadServer(final ServerName serverName) { * * @return true if any RS are being processed as dead */ - public synchronized boolean areDeadServersInProgress() { return processing; } + public synchronized boolean areDeadServersInProgress() { + return !processingServers.isEmpty(); + } public synchronized Set copyServerNames() { Set clone = new HashSet<>(deadServers.size()); @@ -112,10 +126,13 @@ public synchronized Set copyServerNames() { * @param sn the server name */ public synchronized void add(ServerName sn) { - processing = true; if (!deadServers.containsKey(sn)){ deadServers.put(sn, EnvironmentEdgeManager.currentTime()); } + boolean added = processingServers.add(sn); + if (LOG.isDebugEnabled() && added) { + LOG.debug("Added " + sn + "; numProcessing=" + processingServers.size()); + } } /** @@ -123,18 +140,27 @@ public synchronized void add(ServerName sn) { * @param sn ServerName for the dead server. */ public synchronized void notifyServer(ServerName sn) { - if (LOG.isTraceEnabled()) { LOG.trace("Started processing " + sn); } - processing = true; - numProcessing++; + boolean added = processingServers.add(sn); + if (LOG.isDebugEnabled()) { + if (added) { + LOG.debug("Added " + sn + "; numProcessing=" + processingServers.size()); + } + LOG.debug("Started processing " + sn + "; numProcessing=" + processingServers.size()); + } } + /** + * Complete processing for this dead server. + * @param sn ServerName for the dead server. + */ public synchronized void finish(ServerName sn) { - numProcessing--; - if (LOG.isTraceEnabled()) LOG.trace("Finished " + sn + "; numProcessing=" + numProcessing); - - assert numProcessing >= 0: "Number of dead servers in processing should always be non-negative"; - - if (numProcessing == 0) { processing = false; } + boolean removed = processingServers.remove(sn); + if (LOG.isDebugEnabled()) { + LOG.debug("Finished processing " + sn + "; numProcessing=" + processingServers.size()); + if (removed) { + LOG.debug("Removed " + sn + " ; numProcessing=" + processingServers.size()); + } + } } public synchronized int size() { @@ -150,19 +176,33 @@ public synchronized void cleanAllPreviousInstances(final ServerName newServerNam while (it.hasNext()) { ServerName sn = it.next(); if (ServerName.isSameAddress(sn, newServerName)) { + // remove from deadServers it.remove(); + // remove from processingServers + boolean removed = processingServers.remove(sn); + if (removed) { + LOG.debug("Removed " + sn + " ; numProcessing=" + processingServers.size()); + } } } } @Override public synchronized String toString() { + // Display unified set of servers from both maps + Set servers = new HashSet(); + servers.addAll(deadServers.keySet()); + servers.addAll(processingServers); StringBuilder sb = new StringBuilder(); - for (ServerName sn : deadServers.keySet()) { + for (ServerName sn : servers) { if (sb.length() > 0) { sb.append(", "); } sb.append(sn.toString()); + // Star entries that are being processed + if (processingServers.contains(sn)) { + sb.append("*"); + } } return sb.toString(); } @@ -211,6 +251,9 @@ public int compare(Pair o1, Pair o2) { */ public synchronized boolean removeDeadServer(final ServerName deadServerName) { + Preconditions.checkState(!processingServers.contains(deadServerName), + "Asked to remove server still in processingServers set " + deadServerName + + " (numProcessing=" + processingServers.size() + ")"); if (deadServers.remove(deadServerName) == null) { return false; } 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 9f95a3a6f877..8eaa87d36b67 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 @@ -55,7 +55,6 @@ import javax.servlet.http.HttpServlet; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpServletResponse; - import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.Path; @@ -64,6 +63,7 @@ import org.apache.hadoop.hbase.ClusterMetrics; import org.apache.hadoop.hbase.ClusterMetrics.Option; import org.apache.hadoop.hbase.ClusterMetricsBuilder; +import org.apache.hadoop.hbase.CompoundConfiguration; import org.apache.hadoop.hbase.DoNotRetryIOException; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.HBaseInterfaceAudience; @@ -75,7 +75,6 @@ import org.apache.hadoop.hbase.PleaseHoldException; import org.apache.hadoop.hbase.ReplicationPeerNotFoundException; import org.apache.hadoop.hbase.ServerName; -import org.apache.hadoop.hbase.TableDescriptors; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.TableNotDisabledException; import org.apache.hadoop.hbase.TableNotFoundException; @@ -162,6 +161,7 @@ import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.RemoteProcedureDispatcher.RemoteProcedure; import org.apache.hadoop.hbase.procedure2.RemoteProcedureException; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureStoreListener; import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.quotas.MasterQuotaManager; import org.apache.hadoop.hbase.quotas.MasterQuotasObserver; @@ -191,6 +191,7 @@ import org.apache.hadoop.hbase.security.UserProvider; import org.apache.hadoop.hbase.trace.TraceUtil; import org.apache.hadoop.hbase.util.Addressing; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.CompressionTest; import org.apache.hadoop.hbase.util.EncryptionTest; @@ -206,7 +207,6 @@ import org.apache.hadoop.hbase.util.VersionInfo; import org.apache.hadoop.hbase.zookeeper.LoadBalancerTracker; import org.apache.hadoop.hbase.zookeeper.MasterAddressTracker; -import org.apache.hadoop.hbase.zookeeper.MasterMaintenanceModeTracker; import org.apache.hadoop.hbase.zookeeper.RegionNormalizerTracker; import org.apache.hadoop.hbase.zookeeper.ZKClusterId; import org.apache.hadoop.hbase.zookeeper.ZKUtil; @@ -328,9 +328,6 @@ public void run() { // Tracker for region normalizer state private RegionNormalizerTracker regionNormalizerTracker; - //Tracker for master maintenance mode setting - private MasterMaintenanceModeTracker maintenanceModeTracker; - private ClusterSchemaService clusterSchemaService; public static final String HBASE_MASTER_WAIT_ON_SERVICE_IN_SECONDS = @@ -440,6 +437,11 @@ public void run() { /** jetty server for master to redirect requests to regionserver infoServer */ private Server masterJettyServer; + // Determine if we should do normal startup or minimal "single-user" mode with no region + // servers and no user tables. Useful for repair and recovery of hbase:meta + private final boolean maintenanceMode; + static final String MAINTENANCE_MODE = "hbase.master.maintenance_mode"; + public static class RedirectServlet extends HttpServlet { private static final long serialVersionUID = 2894774810058302473L; private final int regionServerInfoPort; @@ -499,6 +501,16 @@ public HMaster(final Configuration conf) super(conf); TraceUtil.initTracer(conf); try { + if (conf.getBoolean(MAINTENANCE_MODE, false)) { + LOG.info("Detected {}=true via configuration.", MAINTENANCE_MODE); + maintenanceMode = true; + } else if (Boolean.getBoolean(MAINTENANCE_MODE)) { + LOG.info("Detected {}=true via environment variables.", MAINTENANCE_MODE); + maintenanceMode = true; + } else { + maintenanceMode = false; + } + this.rsFatals = new MemoryBoundedLogMessageBuffer( conf.getLong("hbase.master.buffer.for.rs.fatals", 1 * 1024 * 1024)); LOG.info("hbase.rootdir=" + getRootDir() + @@ -683,6 +695,9 @@ protected void login(UserProvider user, String host) throws IOException { */ @Override protected void waitForMasterActive(){ + if (maintenanceMode) { + return; + } boolean tablesOnMaster = LoadBalancer.isTablesOnMaster(conf); while (!(tablesOnMaster && activeMaster) && !isStopped() && !isAborted()) { sleeper.sleep(); @@ -768,9 +783,6 @@ protected void initializeZKBasedSystemTrackers() this.drainingServerTracker = new DrainingServerTracker(zooKeeper, this, this.serverManager); this.drainingServerTracker.start(); - this.maintenanceModeTracker = new MasterMaintenanceModeTracker(zooKeeper); - this.maintenanceModeTracker.start(); - String clientQuorumServers = conf.get(HConstants.CLIENT_ZOOKEEPER_QUORUM); boolean clientZkObserverMode = conf.getBoolean(HConstants.CLIENT_ZOOKEEPER_OBSERVER_MODE, HConstants.DEFAULT_CLIENT_ZOOKEEPER_OBSERVER_MODE); @@ -807,7 +819,7 @@ protected void initializeZKBasedSystemTrackers() this.mpmHost.initialize(this, this.metricsMaster); } - private static final ImmutableSet> UNSUPPORTED_PROCEDURES = + private static final ImmutableSet> UNSUPPORTED_PROCEDURES = ImmutableSet.of(RecoverMetaProcedure.class, AssignProcedure.class, UnassignProcedure.class, MoveRegionProcedure.class); @@ -824,7 +836,7 @@ private void checkUnsupportedProcedure( // support both the old assign/unassign procedures and the new TransitRegionStateProcedure as // there will be conflict in the code for AM. We should finish all these procedures before // upgrading. - for (Class clazz : UNSUPPORTED_PROCEDURES) { + for (Class clazz : UNSUPPORTED_PROCEDURES) { List> procs = procsByType.get(clazz); if (procs != null) { LOG.error( @@ -846,6 +858,12 @@ private void checkUnsupportedProcedure( } } + // Will be overriden in test to inject customized AssignmentManager + @VisibleForTesting + protected AssignmentManager createAssignmentManager(MasterServices master) { + return new AssignmentManager(master); + } + /** * Finish initialization of HMaster after becoming the primary master. *

    @@ -938,7 +956,7 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc checkUnsupportedProcedure(procsByType); // Create Assignment Manager - this.assignmentManager = new AssignmentManager(this); + this.assignmentManager = createAssignmentManager(this); this.assignmentManager.start(); // TODO: TRSP can perform as the sub procedure for other procedures, so even if it is marked as // completed, it could still be in the procedure list. This is a bit strange but is another @@ -987,14 +1005,16 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc new ReplicationPeerConfigUpgrader(zooKeeper, conf); tableCFsUpdater.copyTableCFs(); - // Add the Observer to delete quotas on table deletion before starting all CPs by - // default with quota support, avoiding if user specifically asks to not load this Observer. - if (QuotaUtil.isQuotaEnabled(conf)) { - updateConfigurationForQuotasObserver(conf); + if (!maintenanceMode) { + // Add the Observer to delete quotas on table deletion before starting all CPs by + // default with quota support, avoiding if user specifically asks to not load this Observer. + if (QuotaUtil.isQuotaEnabled(conf)) { + updateConfigurationForQuotasObserver(conf); + } + // initialize master side coprocessors before we start handling requests + status.setStatus("Initializing master coprocessors"); + this.cpHost = new MasterCoprocessorHost(this, this.conf); } - // initialize master side coprocessors before we start handling requests - status.setStatus("Initializing master coprocessors"); - this.cpHost = new MasterCoprocessorHost(this, this.conf); // Checking if meta needs initializing. status.setStatus("Initializing meta table if this is a new deploy"); @@ -1004,15 +1024,14 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc getRegionState(RegionInfoBuilder.FIRST_META_REGIONINFO); LOG.info("hbase:meta {}", rs); if (rs.isOffline()) { - Optional> optProc = procedureExecutor.getProcedures().stream() - .filter(p -> p instanceof InitMetaProcedure).findAny(); - if (optProc.isPresent()) { - initMetaProc = (InitMetaProcedure) optProc.get(); - } else { + Optional optProc = procedureExecutor.getProcedures().stream() + .filter(p -> p instanceof InitMetaProcedure).map(o -> (InitMetaProcedure) o).findAny(); + initMetaProc = optProc.orElseGet(() -> { // schedule an init meta procedure if meta has not been deployed yet - initMetaProc = new InitMetaProcedure(); - procedureExecutor.submitProcedure(initMetaProc); - } + InitMetaProcedure temp = new InitMetaProcedure(); + procedureExecutor.submitProcedure(temp); + return temp; + }); } if (this.balancer instanceof FavoredNodesPromoter) { favoredNodesManager = new FavoredNodesManager(this); @@ -1052,15 +1071,15 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc // This is the FIRST attempt at going to hbase:meta. Meta on-lining is going on in background // as procedures run -- in particular SCPs for crashed servers... One should put up hbase:meta // if it is down. It may take a while to come online. So, wait here until meta if for sure - // available. Thats what waitUntilMetaOnline does. - if (!waitUntilMetaOnline()) { + // available. That's what waitForMetaOnline does. + if (!waitForMetaOnline()) { return; } this.assignmentManager.joinCluster(); // The below depends on hbase:meta being online. this.tableStateManager.start(); // Initialize after meta is up as below scans meta - if (favoredNodesManager != null) { + if (favoredNodesManager != null && !maintenanceMode) { SnapshotOfRegionAssignmentFromMeta snapshotOfRegionAssignment = new SnapshotOfRegionAssignmentFromMeta(getConnection()); snapshotOfRegionAssignment.initialize(); @@ -1086,7 +1105,7 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc // Here we expect hbase:namespace to be online. See inside initClusterSchemaService. // TODO: Fix this. Namespace is a pain being a sort-of system table. Fold it in to hbase:meta. // isNamespace does like isMeta and waits until namespace is onlined before allowing progress. - if (!waitUntilNamespaceOnline()) { + if (!waitForNamespaceOnline()) { return; } status.setStatus("Starting cluster schema service"); @@ -1109,6 +1128,12 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc configurationManager.registerObserver(this.logCleaner); // Set master as 'initialized'. setInitialized(true); + + if (maintenanceMode) { + LOG.info("Detected repair mode, skipping final initialization steps."); + return; + } + assignmentManager.checkIfShouldMoveSystemRegionAsync(); status.setStatus("Assign meta replicas"); MasterMetaBootstrap metaBootstrap = createMetaBootstrap(); @@ -1170,7 +1195,7 @@ private void finishActiveMasterInitialization(MonitoredTask status) throws IOExc * and we will hold here until operator intervention. */ @VisibleForTesting - public boolean waitUntilMetaOnline() throws InterruptedException { + public boolean waitForMetaOnline() throws InterruptedException { return isRegionOnline(RegionInfoBuilder.FIRST_META_REGIONINFO); } @@ -1194,8 +1219,8 @@ private boolean isRegionOnline(RegionInfo ri) throws InterruptedException { // Page will talk about loss of edits, how to schedule at least the meta WAL recovery, and // then how to assign including how to break region lock if one held. LOG.warn("{} is NOT online; state={}; ServerCrashProcedures={}. Master startup cannot " + - "progress, in holding-pattern until region onlined; operator intervention required. " + - "Schedule an assign.", ri.getRegionNameAsString(), rs, optProc.isPresent()); + "progress, in holding-pattern until region onlined.", + ri.getRegionNameAsString(), rs, optProc.isPresent()); // Check once-a-minute. if (rc == null) { rc = new RetryCounterFactory(1000).create(); @@ -1211,7 +1236,7 @@ private boolean isRegionOnline(RegionInfo ri) throws InterruptedException { * @return True if namespace table is up/online. */ @VisibleForTesting - public boolean waitUntilNamespaceOnline() throws InterruptedException { + public boolean waitForNamespaceOnline() throws InterruptedException { List ris = this.assignmentManager.getRegionStates(). getRegionsOfTable(TableName.NAMESPACE_TABLE_NAME); if (ris.isEmpty()) { @@ -1345,11 +1370,6 @@ boolean isCleanerChoreEnabled() { return (hfileCleanerFlag && logCleanerFlag); } - @Override - public TableDescriptors getTableDescriptors() { - return this.tableDescriptors; - } - @Override public ServerManager getServerManager() { return this.serverManager; @@ -1479,7 +1499,13 @@ private void createProcedureExecutor() throws IOException { MasterProcedureEnv procEnv = new MasterProcedureEnv(this); procedureStore = new WALProcedureStore(conf, new MasterProcedureEnv.WALStoreLeaseRecovery(this)); - procedureStore.registerListener(new MasterProcedureEnv.MasterProcedureStoreListener(this)); + procedureStore.registerListener(new ProcedureStoreListener() { + + @Override + public void abortProcess() { + abort("The Procedure Store lost the lease", null); + } + }); MasterProcedureScheduler procedureScheduler = procEnv.getProcedureScheduler(); procedureExecutor = new ProcedureExecutor<>(conf, procEnv, procedureStore, procedureScheduler); configurationManager.registerObserver(procEnv); @@ -1699,7 +1725,14 @@ public boolean balance(boolean force) throws IOException { for (RegionPlan plan: plans) { LOG.info("balance " + plan); //TODO: bulk assign - this.assignmentManager.moveAsync(plan); + try { + this.assignmentManager.moveAsync(plan); + } catch (HBaseIOException hioe) { + //should ignore failed plans here, avoiding the whole balance plans be aborted + //later calls of balance() can fetch up the failed and skipped plans + LOG.warn("Failed balance plan: {}, just skip it", plan, hioe); + } + //rpCount records balance plans processed, does not care if a plan succeeds rpCount++; balanceThrottling(balanceStartTime + rpCount * balanceInterval, maxRegionsInTransition, @@ -1748,12 +1781,14 @@ public boolean normalizeRegions() throws IOException { LOG.debug("Master has not been initialized, don't run region normalizer."); return false; } - + if (this.getServerManager().isClusterShutdown()) { + LOG.info("Cluster is shutting down, don't run region normalizer."); + return false; + } if (isInMaintenanceMode()) { LOG.info("Master is in maintenance mode, don't run region normalizer."); return false; } - if (!this.regionNormalizerTracker.isNormalizerOn()) { LOG.debug("Region normalization is disabled, don't run region normalizer."); return false; @@ -2153,6 +2188,8 @@ private void sanityCheckTableDescriptor(final TableDescriptor htd) throws IOExce // check replication scope checkReplicationScope(hcd); + // check bloom filter type + checkBloomFilterType(hcd); // check data replication factor, it can be 0(default value) when user has not explicitly // set the value, in this case we use default replication factor set in the file system. @@ -2235,6 +2272,16 @@ private void checkCompactionPolicy(Configuration conf, TableDescriptor htd) } } + private static void checkBloomFilterType(ColumnFamilyDescriptor cfd) + throws IOException { + Configuration conf = new CompoundConfiguration().addStringMap(cfd.getConfiguration()); + try { + BloomFilterUtil.getBloomFilterParam(cfd.getBloomFilterType(), conf); + } catch (IllegalArgumentException e) { + throw new DoNotRetryIOException("Failed to get bloom filter param", e); + } + } + // HBASE-13350 - Helper method to log warning on sanity check failures if checks disabled. private static void warnOrThrowExceptionForFailure(boolean logWarn, String confKey, String message, Exception cause) throws IOException { @@ -2999,7 +3046,8 @@ public void stop(String msg) { } } - void checkServiceStarted() throws ServerNotRunningYetException { + @VisibleForTesting + protected void checkServiceStarted() throws ServerNotRunningYetException { if (!serviceStarted) { throw new ServerNotRunningYetException("Server is not running yet"); } @@ -3055,11 +3103,8 @@ public boolean isInitialized() { * @return true if master is in maintenanceMode */ @Override - public boolean isInMaintenanceMode() throws IOException { - if (!isInitialized()) { - throw new PleaseHoldException("Master is initializing"); - } - return maintenanceModeTracker.isInMaintenanceMode(); + public boolean isInMaintenanceMode() { + return maintenanceMode; } @VisibleForTesting @@ -3578,14 +3623,9 @@ public void requestMobCompaction(TableName tableName, * @return The state of the load balancer, or false if the load balancer isn't defined. */ public boolean isBalancerOn() { - try { - if (null == loadBalancerTracker || isInMaintenanceMode()) { - return false; - } - } catch (IOException e) { - return false; - } - return loadBalancerTracker.isBalancerOn(); + return !isInMaintenanceMode() + && loadBalancerTracker != null + && loadBalancerTracker.isBalancerOn(); } /** @@ -3593,12 +3633,9 @@ public boolean isBalancerOn() { * false is returned. */ public boolean isNormalizerOn() { - try { - return (null == regionNormalizerTracker || isInMaintenanceMode()) ? - false: regionNormalizerTracker.isNormalizerOn(); - } catch (IOException e) { - return false; - } + return !isInMaintenanceMode() + && regionNormalizerTracker != null + && regionNormalizerTracker.isNormalizerOn(); } /** @@ -3609,14 +3646,9 @@ public boolean isNormalizerOn() { */ @Override public boolean isSplitOrMergeEnabled(MasterSwitchType switchType) { - try { - if (null == splitOrMergeTracker || isInMaintenanceMode()) { - return false; - } - } catch (IOException e) { - return false; - } - return splitOrMergeTracker.isSplitOrMergeEnabled(switchType); + return !isInMaintenanceMode() + && splitOrMergeTracker != null + && splitOrMergeTracker.isSplitOrMergeEnabled(switchType); } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/LoadBalancer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/LoadBalancer.java index aa88f499ba25..816636f8ae07 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/LoadBalancer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/LoadBalancer.java @@ -53,13 +53,12 @@ public interface LoadBalancer extends Configurable, Stoppable, ConfigurationObse * By default, it carries no tables. * TODO: Add any | system as flags to indicate what it can do. */ - public static final String TABLES_ON_MASTER = "hbase.balancer.tablesOnMaster"; + String TABLES_ON_MASTER = "hbase.balancer.tablesOnMaster"; /** * Master carries system tables. */ - public static final String SYSTEM_TABLES_ON_MASTER = - "hbase.balancer.tablesOnMaster.systemTablesOnly"; + String SYSTEM_TABLES_ON_MASTER = "hbase.balancer.tablesOnMaster.systemTablesOnly"; // Used to signal to the caller that the region(s) cannot be assigned // We deliberately use 'localhost' so the operation will fail fast @@ -164,6 +163,9 @@ ServerName randomAssignment( */ void postMasterStartupInitialize(); + /*Updates balancer status tag reported to JMX*/ + void updateBalancerStatus(boolean status); + /** * @return true if Master carries regions */ @@ -174,4 +176,8 @@ static boolean isTablesOnMaster(Configuration conf) { static boolean isSystemTablesOnlyOnMaster(Configuration conf) { return conf.getBoolean(SYSTEM_TABLES_ON_MASTER, false); } + + static boolean isMasterCanHostUserRegions(Configuration conf) { + return isTablesOnMaster(conf) && !isSystemTablesOnlyOnMaster(conf); + } } 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 52424e3b8465..a6bc086d7a59 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 @@ -43,7 +43,6 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.UnknownRegionException; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; -import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.MasterSwitchType; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.RegionInfoBuilder; @@ -354,7 +353,7 @@ protected RpcServerInterface createRpcServer(Server server, Configuration conf, throws IOException { // RpcServer at HM by default enable ByteBufferPool iff HM having user table region in it boolean reservoirEnabled = conf.getBoolean(RESERVOIR_ENABLED_KEY, - (LoadBalancer.isTablesOnMaster(conf) && !LoadBalancer.isSystemTablesOnlyOnMaster(conf))); + LoadBalancer.isMasterCanHostUserRegions(conf)); try { return RpcServerFactory.createRpcServer(server, name, getServices(), bindAddress, // use final bindAddress for this server. @@ -422,6 +421,7 @@ boolean switchBalancer(final boolean b, BalanceSwitchMode mode) throws IOExcepti if (master.cpHost != null) { master.cpHost.postBalanceSwitch(oldValue, newValue); } + master.getLoadBalancer().updateBalancerStatus(newValue); } catch (IOException ioe) { LOG.warn("Error flipping balance switch", ioe); } @@ -597,7 +597,7 @@ public BalanceResponse balance(RpcController controller, BalanceRequest request) throws ServiceException { try { return BalanceResponse.newBuilder().setBalancerRan(master.balance( - request.hasForce() ? request.getForce() : false)).build(); + request.hasForce()? request.getForce(): false)).build(); } catch (IOException ex) { throw new ServiceException(ex); } @@ -1183,7 +1183,8 @@ public GetProcedureResultResponse getProcedureResult(RpcController controller, if (executor.isFinished(procId)) { builder.setState(GetProcedureResultResponse.State.FINISHED); if (result.isFailed()) { - IOException exception = result.getException().unwrapRemoteIOException(); + IOException exception = + MasterProcedureUtil.unwrapRemoteIOException(result); builder.setException(ForeignExceptionUtil.toProtoForeignException(exception)); } byte[] resultData = result.getResult(); @@ -1523,11 +1524,7 @@ public IsInMaintenanceModeResponse isMasterInMaintenanceMode( final RpcController controller, final IsInMaintenanceModeRequest request) throws ServiceException { IsInMaintenanceModeResponse.Builder response = IsInMaintenanceModeResponse.newBuilder(); - try { - response.setInMaintenanceMode(master.isInMaintenanceMode()); - } catch (IOException e) { - throw new ServiceException(e); - } + response.setInMaintenanceMode(master.isInMaintenanceMode()); return response.build(); } @@ -2328,16 +2325,126 @@ public FileArchiveNotificationResponse reportFileArchival(RpcController controll @Override public GetTableStateResponse setTableStateInMeta(RpcController controller, SetTableStateInMetaRequest request) throws ServiceException { - Connection conn = master.getConnection(); TableName tn = ProtobufUtil.toTableName(request.getTableName()); - try { - HBaseProtos.TableState prevState = MetaTableAccessor.getTableState(conn, tn).convert(); - MetaTableAccessor.updateTableState(conn, tn, + HBaseProtos.TableState prevState = + this.master.getTableStateManager().getTableState(tn).convert(); + this.master.getTableStateManager().setTableState(tn, TableState.convert(tn, request.getTableState()).getState()); return GetTableStateResponse.newBuilder().setTableState(prevState).build(); } catch (Exception e) { throw new ServiceException(e); } } + + /** + * Get RegionInfo from Master using content of RegionSpecifier as key. + * @return RegionInfo found by decoding rs or null if none found + */ + private RegionInfo getRegionInfo(HBaseProtos.RegionSpecifier rs) throws UnknownRegionException { + RegionInfo ri = null; + switch(rs.getType()) { + case REGION_NAME: + final byte[] regionName = rs.getValue().toByteArray(); + ri = this.master.getAssignmentManager().getRegionInfo(regionName); + break; + case ENCODED_REGION_NAME: + String encodedRegionName = Bytes.toString(rs.getValue().toByteArray()); + RegionState regionState = this.master.getAssignmentManager().getRegionStates(). + getRegionState(encodedRegionName); + ri = regionState == null? null: regionState.getRegion(); + break; + default: + break; + } + return ri; + } + + /** + * A 'raw' version of assign that does bulk and skirts Master state checks (assigns can be made + * during Master startup). For use by Hbck2. + */ + @Override + public MasterProtos.AssignsResponse assigns(RpcController controller, + MasterProtos.AssignsRequest request) + throws ServiceException { + LOG.info(master.getClientIdAuditPrefix() + " assigns"); + if (this.master.getMasterProcedureExecutor() == null) { + throw new ServiceException("Master's ProcedureExecutor not initialized; retry later"); + } + MasterProtos.AssignsResponse.Builder responseBuilder = + MasterProtos.AssignsResponse.newBuilder(); + try { + boolean override = request.getOverride(); + for (HBaseProtos.RegionSpecifier rs: request.getRegionList()) { + RegionInfo ri = getRegionInfo(rs); + if (ri == null) { + LOG.info("Unknown={}", rs); + responseBuilder.addPid(Procedure.NO_PROC_ID); + continue; + } + responseBuilder.addPid(this.master.getMasterProcedureExecutor().submitProcedure(this.master + .getAssignmentManager().createOneAssignProcedure(ri, override))); + } + return responseBuilder.build(); + } catch (IOException ioe) { + throw new ServiceException(ioe); + } + } + + /** + * A 'raw' version of unassign that does bulk and skirts Master state checks (unassigns can be + * made during Master startup). For use by Hbck2. + */ + @Override + public MasterProtos.UnassignsResponse unassigns(RpcController controller, + MasterProtos.UnassignsRequest request) + throws ServiceException { + LOG.info(master.getClientIdAuditPrefix() + " unassigns"); + if (this.master.getMasterProcedureExecutor() == null) { + throw new ServiceException("Master's ProcedureExecutor not initialized; retry later"); + } + MasterProtos.UnassignsResponse.Builder responseBuilder = + MasterProtos.UnassignsResponse.newBuilder(); + try { + boolean override = request.getOverride(); + for (HBaseProtos.RegionSpecifier rs: request.getRegionList()) { + RegionInfo ri = getRegionInfo(rs); + if (ri == null) { + LOG.info("Unknown={}", rs); + responseBuilder.addPid(Procedure.NO_PROC_ID); + continue; + } + responseBuilder.addPid(this.master.getMasterProcedureExecutor().submitProcedure(this.master + .getAssignmentManager().createOneUnassignProcedure(ri, override))); + } + return responseBuilder.build(); + } catch (IOException ioe) { + throw new ServiceException(ioe); + } + } + + /** + * Bypass specified procedure to completion. Procedure is marked completed but no actual work + * is done from the current state/ step onwards. Parents of the procedure are also marked for + * bypass. + * + * NOTE: this is a dangerous operation and may be used to unstuck buggy procedures. This may + * leave system in inconherent state. This may need to be followed by some cleanup steps/ + * actions by operator. + * + * @return BypassProcedureToCompletionResponse indicating success or failure + */ + @Override + public MasterProtos.BypassProcedureResponse bypassProcedure(RpcController controller, + MasterProtos.BypassProcedureRequest request) throws ServiceException { + try { + List ret = + master.getMasterProcedureExecutor().bypassProcedure(request.getProcIdList(), + request.getWaitTime(), request.getOverride(), request.getRecursive()); + return MasterProtos.BypassProcedureResponse.newBuilder().addAllBypassed(ret).build(); + } catch (IOException e) { + throw new ServiceException(e); + } + } } 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 7b0c56a924ee..27ef5f8cfcd4 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 @@ -351,7 +351,7 @@ long splitRegion( * @return true if master is in maintanceMode * @throws IOException if the inquiry failed due to an IO problem */ - boolean isInMaintenanceMode() throws IOException; + boolean isInMaintenanceMode(); /** * Abort a procedure. diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java index b2aedf09bef8..f419732eb85a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/RegionServerTracker.java @@ -126,8 +126,8 @@ public void start(Set deadServersFromPE, Set liveServers // deadServersFromPE is made from a list of outstanding ServerCrashProcedures. // splittingServersFromWALDir are being actively split -- the directory in the FS ends in // '-SPLITTING'. Each splitting server should have a corresponding SCP. Log if not. - splittingServersFromWALDir.stream().map(s -> !deadServersFromPE.contains(s)). - forEach(s -> LOG.error("{} has no matching ServerCrashProcedure", s)); + splittingServersFromWALDir.stream().filter(s -> !deadServersFromPE.contains(s)). + forEach(s -> LOG.error("{} has no matching ServerCrashProcedure", s)); watcher.registerListener(this); synchronized (this) { List servers = 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 68b8e7996467..dc76d72f5888 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 @@ -761,19 +761,22 @@ public AdminService.BlockingInterface getRsAdmin(final ServerName sn) * RegionServers to check-in. */ private int getMinToStart() { - // One server should be enough to get us off the ground. - int requiredMinToStart = 1; - if (LoadBalancer.isTablesOnMaster(master.getConfiguration())) { - if (LoadBalancer.isSystemTablesOnlyOnMaster(master.getConfiguration())) { - // If Master is carrying regions but NOT user-space regions, it - // still shows as a 'server'. We need at least one more server to check - // in before we can start up so set defaultMinToStart to 2. - requiredMinToStart = requiredMinToStart + 1; - } + if (master.isInMaintenanceMode()) { + // If in maintenance mode, then master hosting meta will be the only server available + return 1; + } + + int minimumRequired = 1; + if (LoadBalancer.isTablesOnMaster(master.getConfiguration()) && + LoadBalancer.isSystemTablesOnlyOnMaster(master.getConfiguration())) { + // If Master is carrying regions it will show up as a 'server', but is not handling user- + // space regions, so we need a second server. + minimumRequired = 2; } + int minToStart = this.master.getConfiguration().getInt(WAIT_ON_REGIONSERVERS_MINTOSTART, -1); - // Ensure we are never less than requiredMinToStart else stuff won't work. - return minToStart == -1 || minToStart < requiredMinToStart? requiredMinToStart: minToStart; + // Ensure we are never less than minimumRequired else stuff won't work. + return Math.max(minToStart, minimumRequired); } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java index d30dcc987916..e6134e875fa0 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManager.java @@ -131,7 +131,7 @@ public class AssignmentManager implements ServerListener { public static final String ASSIGN_MAX_ATTEMPTS = "hbase.assignment.maximum.attempts"; - private static final int DEFAULT_ASSIGN_MAX_ATTEMPTS = 10; + private static final int DEFAULT_ASSIGN_MAX_ATTEMPTS = Integer.MAX_VALUE; /** Region in Transition metrics threshold time */ public static final String METRICS_RIT_STUCK_WARNING_THRESHOLD = @@ -544,7 +544,8 @@ private void preTransitCheck(RegionStateNode regionNode, RegionState.State[] exp } } - public void assign(RegionInfo regionInfo, ServerName sn) throws IOException { + // TODO: Need an async version of this for hbck2. + public long assign(RegionInfo regionInfo, ServerName sn) throws IOException { // TODO: should we use getRegionStateNode? RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(regionInfo); TransitRegionStateProcedure proc; @@ -557,13 +558,14 @@ public void assign(RegionInfo regionInfo, ServerName sn) throws IOException { regionNode.unlock(); } ProcedureSyncWait.submitAndWaitProcedure(master.getMasterProcedureExecutor(), proc); + return proc.getProcId(); } - public void assign(RegionInfo regionInfo) throws IOException { - assign(regionInfo, null); + public long assign(RegionInfo regionInfo) throws IOException { + return assign(regionInfo, null); } - public void unassign(RegionInfo regionInfo) throws IOException { + public long unassign(RegionInfo regionInfo) throws IOException { RegionStateNode regionNode = regionStates.getRegionStateNode(regionInfo); if (regionNode == null) { throw new UnknownRegionException("No RegionState found for " + regionInfo.getEncodedName()); @@ -578,6 +580,7 @@ public void unassign(RegionInfo regionInfo) throws IOException { regionNode.unlock(); } ProcedureSyncWait.submitAndWaitProcedure(master.getMasterProcedureExecutor(), proc); + return proc.getProcId(); } private TransitRegionStateProcedure createMoveRegionProcedure(RegionInfo regionInfo, @@ -679,10 +682,13 @@ static int compare(TransitRegionStateProcedure left, TransitRegionStateProcedure } private TransitRegionStateProcedure createAssignProcedure(RegionStateNode regionNode, - ServerName targetServer) { + ServerName targetServer, boolean override) { TransitRegionStateProcedure proc; regionNode.lock(); try { + if(override && regionNode.getProcedure() != null) { + regionNode.unsetProcedure(regionNode.getProcedure()); + } assert regionNode.getProcedure() == null; proc = TransitRegionStateProcedure.assign(getProcedureEnvironment(), regionNode.getRegionInfo(), targetServer); @@ -693,6 +699,42 @@ private TransitRegionStateProcedure createAssignProcedure(RegionStateNode region return proc; } + private TransitRegionStateProcedure createUnassignProcedure(RegionStateNode regionNode, + boolean override) { + TransitRegionStateProcedure proc; + regionNode.lock(); + try { + if(override && regionNode.getProcedure() != null) { + regionNode.unsetProcedure(regionNode.getProcedure()); + } + assert regionNode.getProcedure() == null; + proc = TransitRegionStateProcedure.unassign(getProcedureEnvironment(), + regionNode.getRegionInfo()); + regionNode.setProcedure(proc); + } finally { + regionNode.unlock(); + } + return proc; + } + + /** + * Create one TransitRegionStateProcedure to assign a region w/o specifying a target server. + * This method is specified for HBCK2 + */ + public TransitRegionStateProcedure createOneAssignProcedure(RegionInfo hri, boolean override) { + RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(hri); + return createAssignProcedure(regionNode, null, override); + } + + /** + * Create one TransitRegionStateProcedure to unassign a region. + * This method is specified for HBCK2 + */ + public TransitRegionStateProcedure createOneUnassignProcedure(RegionInfo hri, boolean override) { + RegionStateNode regionNode = regionStates.getOrCreateRegionStateNode(hri); + return createUnassignProcedure(regionNode, override); + } + /** * Create an array of TransitRegionStateProcedure w/o specifying a target server. *

    @@ -704,8 +746,8 @@ private TransitRegionStateProcedure createAssignProcedure(RegionStateNode region */ public TransitRegionStateProcedure[] createAssignProcedures(List hris) { return hris.stream().map(hri -> regionStates.getOrCreateRegionStateNode(hri)) - .map(regionNode -> createAssignProcedure(regionNode, null)).sorted(AssignmentManager::compare) - .toArray(TransitRegionStateProcedure[]::new); + .map(regionNode -> createAssignProcedure(regionNode, null, false)) + .sorted(AssignmentManager::compare).toArray(TransitRegionStateProcedure[]::new); } /** @@ -716,7 +758,7 @@ private TransitRegionStateProcedure[] createAssignProcedures( Map> assignments) { return assignments.entrySet().stream() .flatMap(e -> e.getValue().stream().map(hri -> regionStates.getOrCreateRegionStateNode(hri)) - .map(regionNode -> createAssignProcedure(regionNode, e.getKey()))) + .map(regionNode -> createAssignProcedure(regionNode, e.getKey(), false))) .sorted(AssignmentManager::compare).toArray(TransitRegionStateProcedure[]::new); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java index 7f2d11a82ec5..36ac6cfb3de2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/AssignmentManagerUtil.java @@ -140,26 +140,45 @@ static TransitRegionStateProcedure[] createUnassignProceduresForSplitOrMerge( return procs; } + /** + * Create assign procedures for the give regions, according to the {@code regionReplication}. + *

    + * For rolling back, we will submit procedures directly to the {@code ProcedureExecutor}, so it is + * possible that we persist the newly scheduled procedures, and then crash before persisting the + * rollback state, so when we arrive here the second time, it is possible that some regions have + * already been associated with a TRSP. + * @param ignoreIfInTransition if true, will skip creating TRSP for the given region if it is + * already in transition, otherwise we will add an assert that it should not in + * transition. + */ private static TransitRegionStateProcedure[] createAssignProcedures(MasterProcedureEnv env, - List regions, int regionReplication, ServerName targetServer) { + List regions, int regionReplication, ServerName targetServer, + boolean ignoreIfInTransition) { // create the assign procs only for the primary region using the targetServer - TransitRegionStateProcedure[] primaryRegionProcs = regions.stream() - .map(env.getAssignmentManager().getRegionStates()::getOrCreateRegionStateNode) + TransitRegionStateProcedure[] primaryRegionProcs = + regions.stream().map(env.getAssignmentManager().getRegionStates()::getOrCreateRegionStateNode) .map(regionNode -> { TransitRegionStateProcedure proc = - TransitRegionStateProcedure.assign(env, regionNode.getRegionInfo(), targetServer); + TransitRegionStateProcedure.assign(env, regionNode.getRegionInfo(), targetServer); regionNode.lock(); try { - // should never fail, as we have the exclusive region lock, and the region is newly - // created, or has been successfully closed so should not be on any servers, so SCP will - // not process it either. - assert !regionNode.isInTransition(); + if (ignoreIfInTransition) { + if (regionNode.isInTransition()) { + return null; + } + } else { + // should never fail, as we have the exclusive region lock, and the region is newly + // created, or has been successfully closed so should not be on any servers, so SCP + // will + // not process it either. + assert !regionNode.isInTransition(); + } regionNode.setProcedure(proc); } finally { regionNode.unlock(); } return proc; - }).toArray(TransitRegionStateProcedure[]::new); + }).filter(p -> p != null).toArray(TransitRegionStateProcedure[]::new); if (regionReplication == DEFAULT_REGION_REPLICA) { // this is the default case return primaryRegionProcs; @@ -184,14 +203,16 @@ private static TransitRegionStateProcedure[] createAssignProcedures(MasterProced static TransitRegionStateProcedure[] createAssignProceduresForOpeningNewRegions( MasterProcedureEnv env, List regions, int regionReplication, ServerName targetServer) { - return createAssignProcedures(env, regions, regionReplication, targetServer); + return createAssignProcedures(env, regions, regionReplication, targetServer, false); } static void reopenRegionsForRollback(MasterProcedureEnv env, List regions, int regionReplication, ServerName targetServer) { TransitRegionStateProcedure[] procs = - createAssignProcedures(env, regions, regionReplication, targetServer); - env.getMasterServices().getMasterProcedureExecutor().submitProcedures(procs); + createAssignProcedures(env, regions, regionReplication, targetServer, true); + if (procs.length > 0) { + env.getMasterServices().getMasterProcedureExecutor().submitProcedures(procs); + } } static void removeNonDefaultReplicas(MasterProcedureEnv env, Stream regions, diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/MergeTableRegionsProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/MergeTableRegionsProcedure.java index efeea594aaed..d3b209e18cec 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/MergeTableRegionsProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/MergeTableRegionsProcedure.java @@ -757,14 +757,16 @@ private ServerName getServerName(final MasterProcedureEnv env) { } private void writeMaxSequenceIdFile(MasterProcedureEnv env) throws IOException { - FileSystem fs = env.getMasterServices().getMasterFileSystem().getFileSystem(); + FileSystem walFS = env.getMasterServices().getMasterWalManager().getFileSystem(); long maxSequenceId = -1L; for (RegionInfo region : regionsToMerge) { maxSequenceId = - Math.max(maxSequenceId, WALSplitter.getMaxRegionSequenceId(fs, getRegionDir(env, region))); + Math.max(maxSequenceId, WALSplitter.getMaxRegionSequenceId( + walFS, getWALRegionDir(env, region))); } if (maxSequenceId > 0) { - WALSplitter.writeRegionSequenceIdFile(fs, getRegionDir(env, mergedRegion), maxSequenceId); + WALSplitter.writeRegionSequenceIdFile(walFS, getWALRegionDir(env, mergedRegion), + maxSequenceId); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateStore.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateStore.java index 48ec4fbba0c2..ce4bc38cd389 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateStore.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/RegionStateStore.java @@ -20,6 +20,7 @@ import java.io.IOException; import java.util.Collections; import java.util.List; +import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellBuilderFactory; import org.apache.hadoop.hbase.CellBuilderType; @@ -34,13 +35,13 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.TableDescriptor; -import org.apache.hadoop.hbase.master.MasterFileSystem; import org.apache.hadoop.hbase.master.MasterServices; import org.apache.hadoop.hbase.master.RegionState.State; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.util.StringUtils; 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.wal.WALSplitter; import org.apache.hadoop.hbase.zookeeper.MetaTableLocator; import org.apache.yetus.audience.InterfaceAudience; @@ -216,9 +217,10 @@ private void updateRegionLocation(RegionInfo regionInfo, State state, Put put) } private long getOpenSeqNumForParentRegion(RegionInfo region) throws IOException { - MasterFileSystem mfs = master.getMasterFileSystem(); + FileSystem walFS = master.getMasterWalManager().getFileSystem(); long maxSeqId = - WALSplitter.getMaxRegionSequenceId(mfs.getFileSystem(), mfs.getRegionDir(region)); + WALSplitter.getMaxRegionSequenceId(walFS, FSUtils.getWALRegionDir( + master.getConfiguration(), region.getTable(), region.getEncodedName())); return maxSeqId > 0 ? maxSeqId + 1 : HConstants.NO_SEQNUM; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/SplitTableRegionProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/SplitTableRegionProcedure.java index 0994c7aed470..bcee8979cc2a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/SplitTableRegionProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/SplitTableRegionProcedure.java @@ -828,12 +828,14 @@ private int getRegionReplication(final MasterProcedureEnv env) throws IOExceptio } private void writeMaxSequenceIdFile(MasterProcedureEnv env) throws IOException { - FileSystem fs = env.getMasterServices().getMasterFileSystem().getFileSystem(); + FileSystem walFS = env.getMasterServices().getMasterWalManager().getFileSystem(); long maxSequenceId = - WALSplitter.getMaxRegionSequenceId(fs, getRegionDir(env, getParentRegion())); + WALSplitter.getMaxRegionSequenceId(walFS, getWALRegionDir(env, getParentRegion())); if (maxSequenceId > 0) { - WALSplitter.writeRegionSequenceIdFile(fs, getRegionDir(env, daughter_1_RI), maxSequenceId); - WALSplitter.writeRegionSequenceIdFile(fs, getRegionDir(env, daughter_2_RI), maxSequenceId); + WALSplitter.writeRegionSequenceIdFile(walFS, getWALRegionDir(env, daughter_1_RI), + maxSequenceId); + WALSplitter.writeRegionSequenceIdFile(walFS, getWALRegionDir(env, daughter_2_RI), + maxSequenceId); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/TransitRegionStateProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/TransitRegionStateProcedure.java index f6d22fa8ada9..df1503ba5dfe 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/TransitRegionStateProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/assignment/TransitRegionStateProcedure.java @@ -39,6 +39,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RegionStateTransitionState; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RegionStateTransitionStateData; @@ -114,7 +115,8 @@ public class TransitRegionStateProcedure public TransitRegionStateProcedure() { } - private TransitRegionStateProcedure(MasterProcedureEnv env, RegionInfo hri, + @VisibleForTesting + protected TransitRegionStateProcedure(MasterProcedureEnv env, RegionInfo hri, ServerName assignCandidate, boolean forceNewPlan, RegionStateTransitionState initialState, RegionStateTransitionState lastState) { super(env, hri); @@ -329,6 +331,7 @@ protected Flow executeFromState(MasterProcedureEnv env, RegionStateTransitionSta backoff / 1000, this, regionNode.toShortString(), e); setTimeout(Math.toIntExact(backoff)); setState(ProcedureProtos.ProcedureState.WAITING_TIMEOUT); + skipPersistence(); throw new ProcedureSuspendedException(); } } @@ -475,8 +478,9 @@ protected RegionStateTransitionState getInitialState() { @Override protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { super.serializeStateData(serializer); - RegionStateTransitionStateData.Builder builder = RegionStateTransitionStateData.newBuilder() - .setInitialState(initialState).setLastState(lastState).setForceNewPlan(forceNewPlan); + RegionStateTransitionStateData.Builder builder = + RegionStateTransitionStateData.newBuilder().setInitialState(initialState) + .setLastState(lastState).setForceNewPlan(forceNewPlan); if (assignCandidate != null) { builder.setAssignCandidate(ProtobufUtil.toServerName(assignCandidate)); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/BaseLoadBalancer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/BaseLoadBalancer.java index 114aee45f51b..3b945bda4f55 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/BaseLoadBalancer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/BaseLoadBalancer.java @@ -51,6 +51,8 @@ import org.apache.hadoop.hbase.master.MasterServices; import org.apache.hadoop.hbase.master.RackManager; import org.apache.hadoop.hbase.master.RegionPlan; +import org.apache.hadoop.hbase.master.assignment.AssignmentManager; +import org.apache.hadoop.hbase.master.assignment.RegionStates; import org.apache.hadoop.hbase.master.balancer.BaseLoadBalancer.Cluster.Action.Type; import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.hbase.thirdparty.com.google.common.base.Joiner; @@ -1010,8 +1012,8 @@ public String toString() { protected ClusterMetrics clusterStatus = null; protected ServerName masterServerName; protected MasterServices services; - protected boolean tablesOnMaster; protected boolean onlySystemTablesOnMaster; + protected boolean maintenanceMode; @Override public void setConf(Configuration conf) { @@ -1023,20 +1025,15 @@ public void setConf(Configuration conf) { if (overallSlop < 0) overallSlop = 0; else if (overallSlop > 1) overallSlop = 1; - this.tablesOnMaster = LoadBalancer.isTablesOnMaster(this.config); this.onlySystemTablesOnMaster = LoadBalancer.isSystemTablesOnlyOnMaster(this.config); - // If system tables on master, implies tablesOnMaster = true. - if (this.onlySystemTablesOnMaster && !this.tablesOnMaster) { - LOG.warn("Set " + TABLES_ON_MASTER + "=true because " + SYSTEM_TABLES_ON_MASTER + "=true"); - this.tablesOnMaster = true; - } + this.rackManager = new RackManager(getConf()); if (useRegionFinder) { regionFinder.setConf(conf); } // Print out base configs. Don't print overallSlop since it for simple balancer exclusively. - LOG.info("slop=" + this.slop + ", tablesOnMaster=" + this.tablesOnMaster + - ", systemTablesOnMaster=" + this.onlySystemTablesOnMaster); + LOG.info("slop={}, systemTablesOnMaster={}", + this.slop, this.onlySystemTablesOnMaster); } protected void setSlop(Configuration conf) { @@ -1049,7 +1046,8 @@ protected void setSlop(Configuration conf) { * If so, the primary replica may be expected to be put on the master regionserver. */ public boolean shouldBeOnMaster(RegionInfo region) { - return this.onlySystemTablesOnMaster && region.getTable().isSystemTable(); + return (this.maintenanceMode || this.onlySystemTablesOnMaster) + && region.getTable().isSystemTable(); } /** @@ -1110,7 +1108,7 @@ protected Map> assignMasterSystemRegions( return null; } Map> assignments = new TreeMap<>(); - if (this.onlySystemTablesOnMaster) { + if (this.maintenanceMode || this.onlySystemTablesOnMaster) { if (masterServerName != null && servers.contains(masterServerName)) { assignments.put(masterServerName, new ArrayList<>()); for (RegionInfo region : regions) { @@ -1148,6 +1146,9 @@ public void setMasterServices(MasterServices masterServices) { if (useRegionFinder) { this.regionFinder.setServices(masterServices); } + if (this.services.isInMaintenanceMode()) { + this.maintenanceMode = true; + } } @Override @@ -1240,7 +1241,7 @@ public Map> roundRobinAssignment(List r regions.removeAll(masterRegions); } } - if (regions == null || regions.isEmpty()) { + if (this.maintenanceMode || regions == null || regions.isEmpty()) { return assignments; } @@ -1413,7 +1414,7 @@ public Map> retainAssignment(Map !masterRegions.contains(e.getKey())) .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue)); } - if (regions.isEmpty()) { + if (this.maintenanceMode || regions.isEmpty()) { return assignments; } @@ -1456,10 +1457,13 @@ public Map> retainAssignment(Map localServers = new ArrayList<>(); @@ -1552,6 +1556,13 @@ public void stop(String why) { stopped = true; } + /** + * Updates the balancer status tag reported to JMX + */ + public void updateBalancerStatus(boolean status) { + metricsBalancer.balancerStatus(status); + } + /** * Used to assign a single region to a random server. */ diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancer.java index c4212694a764..1925568454b9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsBalancer.java @@ -48,4 +48,8 @@ public void balanceCluster(long time) { public void incrMiscInvocations() { source.incrMiscInvocations(); } + + public void balancerStatus(boolean status) { + source.updateBalancerStatus(status); + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsStochasticBalancer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsStochasticBalancer.java index ee24ff3fdb31..6c79f054ee4a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsStochasticBalancer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/MetricsStochasticBalancer.java @@ -56,6 +56,14 @@ public void incrMiscInvocations() { stochasticSource.incrMiscInvocations(); } + /** + * Updates the balancer status tag reported to JMX + */ + @Override + public void balancerStatus(boolean status) { + stochasticSource.updateBalancerStatus(status); + } + /** * Updates the number of metrics reported to JMX */ diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/SimpleLoadBalancer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/SimpleLoadBalancer.java index b0d3f19ad18f..89de13bb78d4 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/SimpleLoadBalancer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/SimpleLoadBalancer.java @@ -479,6 +479,9 @@ public void balanceOverall(List regionsToReturn, for (int i = 0; i < serverLoadList.size(); i++) { ServerAndLoad serverload = serverLoadList.get(i); BalanceInfo balanceInfo = serverBalanceInfo.get(serverload.getServerName()); + if (balanceInfo == null) { + continue; + } setLoad(serverLoadList, i, balanceInfo.getNumRegionsAdded()); if (balanceInfo.getHriList().size() + balanceInfo.getNumRegionsAdded() == max) { RegionInfo hriToPlan; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/StochasticLoadBalancer.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/StochasticLoadBalancer.java index 1ff8d1771cfd..30e4d494d49a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/StochasticLoadBalancer.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/balancer/StochasticLoadBalancer.java @@ -374,9 +374,6 @@ public synchronized List balanceCluster(Map balanceCluster(Map currentCost) { plans = createRegionPlans(cluster); - if (LOG.isDebugEnabled()) { - LOG.debug("Finished computing new load balance plan. Computation took " - + (endTime - startTime) + "ms to try " + step - + " different iterations. Found a solution that moves " - + plans.size() + " regions; Going from a computed cost of " - + initCost + " to a new cost of " + currentCost); - } - + LOG.info("Finished computing new load balance plan. Computation took {}" + + " to try {} different iterations. Found a solution that moves " + + "{} regions; Going from a computed cost of {}" + + " to a new cost of {}", java.time.Duration.ofMillis(endTime - startTime), + step, plans.size(), initCost, currentCost); return plans; } - if (LOG.isDebugEnabled()) { - LOG.debug("Could not find a better load balance plan. Tried " - + step + " different configurations in " + (endTime - startTime) - + "ms, and did not find anything with a computed cost less than " + initCost); - } + LOG.info("Could not find a better load balance plan. Tried {} different configurations in " + + "{}, and did not find anything with a computed cost less than {}", step, + java.time.Duration.ofMillis(endTime - startTime), initCost); return null; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/cleaner/HFileCleaner.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/cleaner/HFileCleaner.java index 47b0228a3196..7ad6177764c2 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/cleaner/HFileCleaner.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/cleaner/HFileCleaner.java @@ -32,6 +32,8 @@ import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.Stoppable; import org.apache.hadoop.hbase.io.HFileLink; +import org.apache.hadoop.hbase.master.HMaster; +import org.apache.hadoop.hbase.master.MasterServices; import org.apache.hadoop.hbase.regionserver.StoreFileInfo; import org.apache.hadoop.hbase.util.StealJobQueue; import org.apache.yetus.audience.InterfaceAudience; @@ -44,6 +46,7 @@ */ @InterfaceAudience.Private public class HFileCleaner extends CleanerChore { + private MasterServices master; public static final String MASTER_HFILE_CLEANER_PLUGINS = "hbase.master.hfilecleaner.plugins"; @@ -496,4 +499,10 @@ public synchronized void cancel(boolean mayInterruptIfRunning) { t.interrupt(); } } + + public void init(Map params) { + if (params != null && params.containsKey(HMaster.MASTER)) { + this.master = (MasterServices) params.get(HMaster.MASTER); + } + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/AbstractStateMachineTableProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/AbstractStateMachineTableProcedure.java index ca4e9d6a1697..431b988eba74 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/AbstractStateMachineTableProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/AbstractStateMachineTableProcedure.java @@ -34,6 +34,7 @@ import org.apache.hadoop.hbase.master.assignment.RegionStateNode; import org.apache.hadoop.hbase.procedure2.StateMachineProcedure; import org.apache.hadoop.hbase.security.User; +import org.apache.hadoop.hbase.util.FSUtils; import org.apache.yetus.audience.InterfaceAudience; /** @@ -128,8 +129,10 @@ protected void checkTableModifiable(final MasterProcedureEnv env) throws IOExcep } } - protected final Path getRegionDir(MasterProcedureEnv env, RegionInfo region) throws IOException { - return env.getMasterServices().getMasterFileSystem().getRegionDir(region); + protected final Path getWALRegionDir(MasterProcedureEnv env, RegionInfo region) + throws IOException { + return FSUtils.getWALRegionDir(env.getMasterConfiguration(), + region.getTable(), region.getEncodedName()); } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/DisableTableProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/DisableTableProcedure.java index f6e46401ef0a..9cacc5d6b956 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/DisableTableProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/DisableTableProcedure.java @@ -19,6 +19,7 @@ package org.apache.hadoop.hbase.master.procedure; import java.io.IOException; +import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.hbase.HBaseIOException; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.MetaTableAccessor; @@ -30,7 +31,6 @@ import org.apache.hadoop.hbase.client.TableState; import org.apache.hadoop.hbase.constraint.ConstraintException; import org.apache.hadoop.hbase.master.MasterCoprocessorHost; -import org.apache.hadoop.hbase.master.MasterFileSystem; import org.apache.hadoop.hbase.master.TableStateManager; import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; @@ -111,13 +111,13 @@ protected Flow executeFromState(final MasterProcedureEnv env, final DisableTable case DISABLE_TABLE_ADD_REPLICATION_BARRIER: if (env.getMasterServices().getTableDescriptors().get(tableName) .hasGlobalReplicationScope()) { - MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem(); + FileSystem walFS = env.getMasterServices().getMasterWalManager().getFileSystem(); try (BufferedMutator mutator = env.getMasterServices().getConnection() .getBufferedMutator(TableName.META_TABLE_NAME)) { for (RegionInfo region : env.getAssignmentManager().getRegionStates() .getRegionsOfTable(tableName)) { long maxSequenceId = - WALSplitter.getMaxRegionSequenceId(mfs.getFileSystem(), mfs.getRegionDir(region)); + WALSplitter.getMaxRegionSequenceId(walFS, getWALRegionDir(env, region)); long openSeqNum = maxSequenceId > 0 ? maxSequenceId + 1 : HConstants.NO_SEQNUM; mutator.mutate(MetaTableAccessor.makePutForReplicationBarrier(region, openSeqNum, EnvironmentEdgeManager.currentTime())); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureEnv.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureEnv.java index 2c01b166b4eb..cd402344c9a3 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureEnv.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureEnv.java @@ -31,7 +31,6 @@ import org.apache.hadoop.hbase.master.replication.ReplicationPeerManager; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureEvent; -import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; import org.apache.hadoop.hbase.procedure2.store.wal.WALProcedureStore; import org.apache.hadoop.hbase.security.Superusers; import org.apache.hadoop.hbase.security.User; @@ -73,26 +72,6 @@ private boolean isRunning() { } } - @InterfaceAudience.Private - public static class MasterProcedureStoreListener - implements ProcedureStore.ProcedureStoreListener { - private final MasterServices master; - - public MasterProcedureStoreListener(final MasterServices master) { - this.master = master; - } - - @Override - public void postSync() { - // no-op - } - - @Override - public void abortProcess() { - master.abort("The Procedure Store lost the lease", null); - } - } - private final RSProcedureDispatcher remoteDispatcher; private final MasterProcedureScheduler procSched; private final MasterServices master; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureScheduler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureScheduler.java index 2a29ee1cbb44..5ee5f496844a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureScheduler.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureScheduler.java @@ -686,7 +686,6 @@ public boolean waitRegions(final Procedure procedure, final TableName table, boolean hasLock = true; final LockAndQueue[] regionLocks = new LockAndQueue[regionInfo.length]; for (int i = 0; i < regionInfo.length; ++i) { - LOG.info("{} checking lock on {}", procedure, regionInfo[i].getEncodedName()); assert regionInfo[i] != null; assert regionInfo[i].getTable() != null; assert regionInfo[i].getTable().equals(table): regionInfo[i] + " " + procedure; @@ -694,12 +693,16 @@ public boolean waitRegions(final Procedure procedure, final TableName table, regionLocks[i] = locking.getRegionLock(regionInfo[i].getEncodedName()); if (!regionLocks[i].tryExclusiveLock(procedure)) { + LOG.info("Waiting on xlock for {} held by pid={}", procedure, + regionLocks[i].getExclusiveLockProcIdOwner()); waitProcedure(regionLocks[i], procedure); hasLock = false; while (i-- > 0) { regionLocks[i].releaseExclusiveLock(procedure); } break; + } else { + LOG.info("Took xlock for {}", procedure); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureUtil.java index 58263d304451..1e488b61857b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureUtil.java @@ -19,9 +19,12 @@ import java.io.IOException; import java.util.regex.Pattern; + +import org.apache.hadoop.hbase.DoNotRetryIOException; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.master.MasterServices; import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureException; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.security.User; import org.apache.hadoop.hbase.util.NonceKey; @@ -176,4 +179,17 @@ public static int getTablePriority(TableName tableName) { public static int getServerPriority(ServerProcedureInterface proc) { return proc.hasMetaTableRegion() ? 100 : 1; } + + /** + * This is a version of unwrapRemoteIOException that can do DoNotRetryIOE. + * We need to throw DNRIOE to clients if a failed Procedure else they will + * keep trying. The default proc.getException().unwrapRemoteException + * doesn't have access to DNRIOE from the procedure2 module. + */ + public static IOException unwrapRemoteIOException(Procedure proc) { + Exception e = proc.getException().unwrapRemoteException(); + // Do not retry ProcedureExceptions! + return (e instanceof ProcedureException)? new DoNotRetryIOException(e): + proc.getException().unwrapRemoteIOException(); + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureDescriber.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureDescriber.java index 41b30ad5a2ff..f9fdad8abaef 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureDescriber.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureDescriber.java @@ -69,7 +69,8 @@ public static String describe(Procedure proc) { description.put("LAST_UPDATE", new Date(proc.getLastUpdate())); if (proc.isFailed()) { - description.put("ERRORS", proc.getException().unwrapRemoteIOException().getMessage()); + description.put("ERRORS", + MasterProcedureUtil.unwrapRemoteIOException(proc).getMessage()); } description.put("PARAMETERS", parametersToObject(proc)); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedurePrepareLatch.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedurePrepareLatch.java index 2011c0b9de9c..f771210b871b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedurePrepareLatch.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedurePrepareLatch.java @@ -99,7 +99,7 @@ protected static class CompatibilityLatch extends ProcedurePrepareLatch { @Override protected void countDown(final Procedure proc) { if (proc.hasException()) { - exception = proc.getException().unwrapRemoteIOException(); + exception = MasterProcedureUtil.unwrapRemoteIOException(proc); } latch.countDown(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java index f72905bb52df..c8ff9f80452b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ProcedureSyncWait.java @@ -160,9 +160,10 @@ public Boolean evaluate() throws IOException { throw new IOException("The Master is Aborting"); } + // If the procedure fails, we should always have an exception captured. Throw it. + // Needs to be an IOE to get out of here. if (proc.hasException()) { - // If the procedure fails, we should always have an exception captured. Throw it. - throw proc.getException().unwrapRemoteIOException(); + throw MasterProcedureUtil.unwrapRemoteIOException(proc); } else { return proc.getResult(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java index 24b1e5ceaf62..06348155f1d7 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/procedure/ReopenTableRegionsProcedure.java @@ -70,6 +70,18 @@ public TableOperationType getTableOperationType() { return TableOperationType.REGION_EDIT; } + private boolean canSchedule(MasterProcedureEnv env, HRegionLocation loc) { + if (loc.getSeqNum() < 0) { + return false; + } + RegionStateNode regionNode = + env.getAssignmentManager().getRegionStates().getRegionStateNode(loc.getRegion()); + // If the region node is null, then at least in the next round we can remove this region to make + // progress. And the second condition is a normal one, if there are no TRSP with it then we can + // schedule one to make progress. + return regionNode == null || !regionNode.isInTransition(); + } + @Override protected Flow executeFromState(MasterProcedureEnv env, ReopenTableRegionsState state) throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { @@ -85,8 +97,12 @@ protected Flow executeFromState(MasterProcedureEnv env, ReopenTableRegionsState return Flow.HAS_MORE_STATE; case REOPEN_TABLE_REGIONS_REOPEN_REGIONS: for (HRegionLocation loc : regions) { - RegionStateNode regionNode = env.getAssignmentManager().getRegionStates() - .getOrCreateRegionStateNode(loc.getRegion()); + RegionStateNode regionNode = + env.getAssignmentManager().getRegionStates().getRegionStateNode(loc.getRegion()); + // this possible, maybe the region has already been merged or split, see HBASE-20921 + if (regionNode == null) { + continue; + } TransitRegionStateProcedure proc; regionNode.lock(); try { @@ -108,13 +124,13 @@ protected Flow executeFromState(MasterProcedureEnv env, ReopenTableRegionsState if (regions.isEmpty()) { return Flow.NO_MORE_STATE; } - if (regions.stream().anyMatch(l -> l.getSeqNum() >= 0)) { + if (regions.stream().anyMatch(loc -> canSchedule(env, loc))) { attempt = 0; setNextState(ReopenTableRegionsState.REOPEN_TABLE_REGIONS_REOPEN_REGIONS); return Flow.HAS_MORE_STATE; } - // All the regions need to reopen are in OPENING state which means we can not schedule any - // MRPs. + // We can not schedule TRSP for all the regions need to reopen, wait for a while and retry + // again. long backoff = ProcedureUtil.getBackoffTimeMs(this.attempt++); LOG.info( "There are still {} region(s) which need to be reopened for table {} are in " + @@ -122,6 +138,7 @@ protected Flow executeFromState(MasterProcedureEnv env, ReopenTableRegionsState regions.size(), tableName, backoff / 1000); setTimeout(Math.toIntExact(backoff)); setState(ProcedureProtos.ProcedureState.WAITING_TIMEOUT); + skipPersistence(); throw new ProcedureSuspendedException(); default: throw new UnsupportedOperationException("unhandled state=" + state); @@ -137,6 +154,7 @@ protected synchronized boolean setTimeoutFailure(MasterProcedureEnv env) { env.getProcedureScheduler().addFront(this); return false; // 'false' means that this procedure handled the timeout } + @Override protected void rollbackState(MasterProcedureEnv env, ReopenTableRegionsState state) throws IOException, InterruptedException { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AbstractPeerProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AbstractPeerProcedure.java index e133a6579f92..d3a4eb8638be 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AbstractPeerProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AbstractPeerProcedure.java @@ -18,14 +18,20 @@ package org.apache.hadoop.hbase.master.replication; import java.io.IOException; + import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; import org.apache.hadoop.hbase.master.procedure.PeerProcedureInterface; import org.apache.hadoop.hbase.master.procedure.ProcedurePrepareLatch; import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; +import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; import org.apache.hadoop.hbase.procedure2.StateMachineProcedure; +import org.apache.hadoop.hbase.replication.ReplicationException; import org.apache.yetus.audience.InterfaceAudience; +import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; + import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.PeerProcedureStateData; +import org.apache.hadoop.hbase.shaded.protobuf.generated.ProcedureProtos; /** * The base class for all replication peer related procedure. @@ -39,6 +45,8 @@ public abstract class AbstractPeerProcedure // used to keep compatible with old client where we can only returns after updateStorage. protected ProcedurePrepareLatch latch; + protected int attempts; + protected AbstractPeerProcedure() { } @@ -106,4 +114,26 @@ protected final void refreshPeer(MasterProcedureEnv env, PeerOperationType type) addChildProcedure(env.getMasterServices().getServerManager().getOnlineServersList().stream() .map(sn -> new RefreshPeerProcedure(peerId, type, sn)).toArray(RefreshPeerProcedure[]::new)); } + + @Override + protected synchronized boolean setTimeoutFailure(MasterProcedureEnv env) { + setState(ProcedureProtos.ProcedureState.RUNNABLE); + env.getProcedureScheduler().addFront(this); + return false; + } + + protected final ProcedureSuspendedException suspend(long backoff) + throws ProcedureSuspendedException { + attempts++; + setTimeout(Math.toIntExact(backoff)); + setState(ProcedureProtos.ProcedureState.WAITING_TIMEOUT); + skipPersistence(); + throw new ProcedureSuspendedException(); + } + + // will be override in test to simulate error + @VisibleForTesting + protected void enablePeer(MasterProcedureEnv env) throws ReplicationException { + env.getReplicationPeerManager().enablePeer(peerId); + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AddPeerProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AddPeerProcedure.java index 2f2d5a5449de..f1c07aac5f95 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AddPeerProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/AddPeerProcedure.java @@ -21,6 +21,7 @@ import org.apache.hadoop.hbase.client.replication.ReplicationPeerConfigUtil; import org.apache.hadoop.hbase.master.MasterCoprocessorHost; import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; +import org.apache.hadoop.hbase.master.procedure.ProcedurePrepareLatch; import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; import org.apache.hadoop.hbase.replication.ReplicationException; import org.apache.hadoop.hbase.replication.ReplicationPeerConfig; @@ -79,13 +80,24 @@ protected ReplicationPeerConfig getNewPeerConfig() { return peerConfig; } + @Override + protected void releaseLatch(MasterProcedureEnv env) { + if (peerConfig.isSyncReplication()) { + env.getReplicationPeerManager().releaseSyncReplicationPeerLock(); + } + ProcedurePrepareLatch.releaseLatch(latch, this); + } + @Override protected void prePeerModification(MasterProcedureEnv env) - throws IOException, ReplicationException { + throws IOException, ReplicationException, InterruptedException { MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost(); if (cpHost != null) { cpHost.preAddReplicationPeer(peerId, peerConfig); } + if (peerConfig.isSyncReplication()) { + env.getReplicationPeerManager().acquireSyncReplicationPeerLock(); + } env.getReplicationPeerManager().preAddPeer(peerId, peerConfig); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ModifyPeerProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ModifyPeerProcedure.java index ad4df610e1f8..9550fb0bc138 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ModifyPeerProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ModifyPeerProcedure.java @@ -32,7 +32,7 @@ import org.apache.hadoop.hbase.master.procedure.ProcedurePrepareLatch; import org.apache.hadoop.hbase.master.procedure.ReopenTableRegionsProcedure; import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; -import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; +import org.apache.hadoop.hbase.procedure2.ProcedureUtil; import org.apache.hadoop.hbase.replication.ReplicationException; import org.apache.hadoop.hbase.replication.ReplicationPeerConfig; import org.apache.hadoop.hbase.replication.ReplicationQueueStorage; @@ -42,6 +42,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; + import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.PeerModificationState; /** @@ -73,7 +75,7 @@ protected ModifyPeerProcedure(String peerId) { * all checks passes then the procedure can not be rolled back any more. */ protected abstract void prePeerModification(MasterProcedureEnv env) - throws IOException, ReplicationException; + throws IOException, ReplicationException, InterruptedException; protected abstract void updatePeerStorage(MasterProcedureEnv env) throws ReplicationException; @@ -89,7 +91,7 @@ protected abstract void prePeerModification(MasterProcedureEnv env) protected abstract void postPeerModification(MasterProcedureEnv env) throws IOException, ReplicationException; - private void releaseLatch() { + protected void releaseLatch(MasterProcedureEnv env) { ProcedurePrepareLatch.releaseLatch(latch, this); } @@ -143,7 +145,9 @@ private boolean needReopen(TableStateManager tsm, TableName tn) throws IOExcepti } } - private void reopenRegions(MasterProcedureEnv env) throws IOException { + // will be override in test to simulate error + @VisibleForTesting + protected void reopenRegions(MasterProcedureEnv env) throws IOException { ReplicationPeerConfig peerConfig = getNewPeerConfig(); ReplicationPeerConfig oldPeerConfig = getOldPeerConfig(); TableStateManager tsm = env.getMasterServices().getTableStateManager(); @@ -237,7 +241,7 @@ protected final void setLastPushedSequenceIdForTable(MasterProcedureEnv env, Tab @Override protected Flow executeFromState(MasterProcedureEnv env, PeerModificationState state) - throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { + throws ProcedureSuspendedException, InterruptedException { switch (state) { case PRE_PEER_MODIFICATION: try { @@ -246,23 +250,27 @@ protected Flow executeFromState(MasterProcedureEnv env, PeerModificationState st LOG.warn("{} failed to call pre CP hook or the pre check is failed for peer {}, " + "mark the procedure as failure and give up", getClass().getName(), peerId, e); setFailure("master-" + getPeerOperationType().name().toLowerCase() + "-peer", e); - releaseLatch(); + releaseLatch(env); return Flow.NO_MORE_STATE; } catch (ReplicationException e) { - LOG.warn("{} failed to call prePeerModification for peer {}, retry", getClass().getName(), - peerId, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("{} failed to call prePeerModification for peer {}, sleep {} secs", + getClass().getName(), peerId, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState(PeerModificationState.UPDATE_PEER_STORAGE); return Flow.HAS_MORE_STATE; case UPDATE_PEER_STORAGE: try { updatePeerStorage(env); } catch (ReplicationException e) { - LOG.warn("{} update peer storage for peer {} failed, retry", getClass().getName(), peerId, - e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("{} update peer storage for peer {} failed, sleep {} secs", getClass().getName(), + peerId, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState(PeerModificationState.REFRESH_PEER_ON_RS); return Flow.HAS_MORE_STATE; case REFRESH_PEER_ON_RS: @@ -273,30 +281,37 @@ protected Flow executeFromState(MasterProcedureEnv env, PeerModificationState st try { reopenRegions(env); } catch (Exception e) { - LOG.warn("{} reopen regions for peer {} failed, retry", getClass().getName(), peerId, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("{} reopen regions for peer {} failed, sleep {} secs", getClass().getName(), + peerId, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState(PeerModificationState.SERIAL_PEER_UPDATE_LAST_PUSHED_SEQ_ID); return Flow.HAS_MORE_STATE; case SERIAL_PEER_UPDATE_LAST_PUSHED_SEQ_ID: try { updateLastPushedSequenceIdForSerialPeer(env); } catch (Exception e) { - LOG.warn("{} set last sequence id for peer {} failed, retry", getClass().getName(), - peerId, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("{} set last sequence id for peer {} failed, sleep {} secs", + getClass().getName(), peerId, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState(enablePeerBeforeFinish() ? PeerModificationState.SERIAL_PEER_SET_PEER_ENABLED : PeerModificationState.POST_PEER_MODIFICATION); return Flow.HAS_MORE_STATE; case SERIAL_PEER_SET_PEER_ENABLED: try { - env.getReplicationPeerManager().enablePeer(peerId); + enablePeer(env); } catch (ReplicationException e) { - LOG.warn("{} enable peer before finish for peer {} failed, retry", getClass().getName(), - peerId, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("{} enable peer before finish for peer {} failed, sleep {} secs", + getClass().getName(), peerId, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState(PeerModificationState.SERIAL_PEER_ENABLE_PEER_REFRESH_PEER_ON_RS); return Flow.HAS_MORE_STATE; case SERIAL_PEER_ENABLE_PEER_REFRESH_PEER_ON_RS: @@ -307,14 +322,15 @@ protected Flow executeFromState(MasterProcedureEnv env, PeerModificationState st try { postPeerModification(env); } catch (ReplicationException e) { - LOG.warn("{} failed to call postPeerModification for peer {}, retry", - getClass().getName(), peerId, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("{} failed to call postPeerModification for peer {}, sleep {} secs", + getClass().getName(), peerId, backoff / 1000, e); + throw suspend(backoff); } catch (IOException e) { LOG.warn("{} failed to call post CP hook for peer {}, " + "ignore since the procedure has already done", getClass().getName(), peerId, e); } - releaseLatch(); + releaseLatch(env); return Flow.NO_MORE_STATE; default: throw new UnsupportedOperationException("unhandled state=" + state); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/RefreshPeerProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/RefreshPeerProcedure.java index 8502edf6e05d..2f43ae9282a3 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/RefreshPeerProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/RefreshPeerProcedure.java @@ -205,6 +205,11 @@ protected boolean abort(MasterProcedureEnv env) { return false; } + @Override + protected boolean waitInitialized(MasterProcedureEnv env) { + return env.waitInitialized(this); + } + @Override protected void serializeStateData(ProcedureStateSerializer serializer) throws IOException { serializer.serialize( diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ReplicationPeerManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ReplicationPeerManager.java index 8e49137f39e8..80338e274032 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ReplicationPeerManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/ReplicationPeerManager.java @@ -28,6 +28,7 @@ import java.util.Set; import java.util.concurrent.ConcurrentHashMap; import java.util.concurrent.ConcurrentMap; +import java.util.concurrent.Semaphore; import java.util.regex.Pattern; import java.util.stream.Collectors; import org.apache.commons.lang3.StringUtils; @@ -75,6 +76,9 @@ public class ReplicationPeerManager { SyncReplicationState.DOWNGRADE_ACTIVE, EnumSet.of(SyncReplicationState.STANDBY, SyncReplicationState.ACTIVE))); + // Only allow to add one sync replication peer concurrently + private final Semaphore syncReplicationPeerLock = new Semaphore(1); + ReplicationPeerManager(ReplicationPeerStorage peerStorage, ReplicationQueueStorage queueStorage, ConcurrentMap peers) { this.peerStorage = peerStorage; @@ -105,6 +109,9 @@ void preAddPeer(String peerId, ReplicationPeerConfig peerConfig) throw new DoNotRetryIOException("Found invalid peer name: " + peerId); } checkPeerConfig(peerConfig); + if (peerConfig.isSyncReplication()) { + checkSyncReplicationPeerConfigConflict(peerConfig); + } if (peers.containsKey(peerId)) { throw new DoNotRetryIOException("Replication peer " + peerId + " already exists"); } @@ -385,6 +392,7 @@ private void checkPeerConfigForSyncReplication(ReplicationPeerConfig peerConfig) "Only support replicated table config for sync replication peer"); } } + Path remoteWALDir = new Path(peerConfig.getRemoteWALDir()); if (!remoteWALDir.isAbsolute()) { throw new DoNotRetryIOException( @@ -397,6 +405,19 @@ private void checkPeerConfigForSyncReplication(ReplicationPeerConfig peerConfig) } } + private void checkSyncReplicationPeerConfigConflict(ReplicationPeerConfig peerConfig) + throws DoNotRetryIOException { + for (TableName tableName : peerConfig.getTableCFsMap().keySet()) { + for (Map.Entry entry : peers.entrySet()) { + ReplicationPeerConfig rpc = entry.getValue().getPeerConfig(); + if (rpc.isSyncReplication() && rpc.getTableCFsMap().containsKey(tableName)) { + throw new DoNotRetryIOException( + "Table " + tableName + " has been replicated by peer " + entry.getKey()); + } + } + } + } + /** * Set a namespace in the peer config means that all tables in this namespace will be replicated * to the peer cluster. @@ -493,4 +514,12 @@ private boolean isStringEquals(String s1, String s2) { } return s1.equals(s2); } + + public void acquireSyncReplicationPeerLock() throws InterruptedException { + syncReplicationPeerLock.acquire(); + } + + public void releaseSyncReplicationPeerLock() { + syncReplicationPeerLock.release(); + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/SyncReplicationReplayWALProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/SyncReplicationReplayWALProcedure.java index 26d6a3f78b44..21a8c81fe24c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/SyncReplicationReplayWALProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/SyncReplicationReplayWALProcedure.java @@ -23,11 +23,9 @@ import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; -import org.apache.hadoop.hbase.master.procedure.PeerProcedureInterface; import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; -import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; -import org.apache.hadoop.hbase.procedure2.StateMachineProcedure; +import org.apache.hadoop.hbase.procedure2.ProcedureUtil; import org.apache.hadoop.hbase.replication.ReplicationException; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; @@ -38,14 +36,11 @@ @InterfaceAudience.Private public class SyncReplicationReplayWALProcedure - extends StateMachineProcedure - implements PeerProcedureInterface { + extends AbstractPeerProcedure { private static final Logger LOG = LoggerFactory.getLogger(SyncReplicationReplayWALProcedure.class); - private String peerId; - private ServerName worker = null; private List wals; @@ -58,9 +53,9 @@ public SyncReplicationReplayWALProcedure(String peerId, List wals) { this.wals = wals; } - @Override protected Flow executeFromState(MasterProcedureEnv env, - SyncReplicationReplayWALState state) - throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { + @Override + protected Flow executeFromState(MasterProcedureEnv env, SyncReplicationReplayWALState state) + throws ProcedureSuspendedException { SyncReplicationReplayWALManager syncReplicationReplayWALManager = env.getMasterServices().getSyncReplicationReplayWALManager(); switch (state) { @@ -68,15 +63,19 @@ public SyncReplicationReplayWALProcedure(String peerId, List wals) { try { worker = syncReplicationReplayWALManager.getPeerWorker(peerId); } catch (ReplicationException e) { - LOG.info("Failed to get worker to replay wals {} for peer id={}, retry", wals, peerId); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("Failed to get worker to replay wals {} for peer id={}, sleep {} secs and retry", + wals, peerId, backoff / 1000, e); + throw suspend(backoff); } if (worker == null) { - LOG.info("No worker to replay wals {} for peer id={}, retry", wals, peerId); - setNextState(SyncReplicationReplayWALState.ASSIGN_WORKER); - } else { - setNextState(SyncReplicationReplayWALState.DISPATCH_WALS_TO_WORKER); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.info("No worker to replay wals {} for peer id={}, sleep {} secs and retry", wals, + peerId, backoff / 1000); + throw suspend(backoff); } + attempts = 0; + setNextState(SyncReplicationReplayWALState.DISPATCH_WALS_TO_WORKER); return Flow.HAS_MORE_STATE; case DISPATCH_WALS_TO_WORKER: addChildProcedure(new SyncReplicationReplayWALRemoteProcedure(peerId, wals, worker)); @@ -87,17 +86,23 @@ public SyncReplicationReplayWALProcedure(String peerId, List wals) { try { finished = syncReplicationReplayWALManager.isReplayWALFinished(wals.get(0)); } catch (IOException e) { - LOG.info("Failed to check whether replay wals {} finished for peer id={}", wals, peerId); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("Failed to check whether replay wals {} finished for peer id={}" + + ", sleep {} secs and retry", + wals, peerId, backoff / 1000, e); + throw suspend(backoff); } try { syncReplicationReplayWALManager.removePeerWorker(peerId, worker); } catch (ReplicationException e) { - LOG.info("Failed to remove worker for peer id={}, retry", peerId); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn("Failed to remove worker {} for peer id={}, sleep {} secs and retry", worker, + peerId, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; if (!finished) { - LOG.info("Failed to replay wals {} for peer id={}, retry", wals, peerId); + LOG.warn("Failed to replay wals {} for peer id={}, retry", wals, peerId); setNextState(SyncReplicationReplayWALState.ASSIGN_WORKER); return Flow.HAS_MORE_STATE; } @@ -152,11 +157,6 @@ protected void deserializeStateData(ProcedureStateSerializer serializer) throws data.getWalList().forEach(wals::add); } - @Override - public String getPeerId() { - return peerId; - } - @Override public PeerOperationType getPeerOperationType() { return PeerOperationType.SYNC_REPLICATION_REPLAY_WAL; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/TransitPeerSyncReplicationStateProcedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/TransitPeerSyncReplicationStateProcedure.java index c650974df8f0..8c6232f48c94 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/TransitPeerSyncReplicationStateProcedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/master/replication/TransitPeerSyncReplicationStateProcedure.java @@ -28,7 +28,7 @@ import org.apache.hadoop.hbase.master.procedure.ReopenTableRegionsProcedure; import org.apache.hadoop.hbase.procedure2.ProcedureStateSerializer; import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; -import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; +import org.apache.hadoop.hbase.procedure2.ProcedureUtil; import org.apache.hadoop.hbase.replication.ReplicationException; import org.apache.hadoop.hbase.replication.ReplicationPeerDescription; import org.apache.hadoop.hbase.replication.ReplicationUtils; @@ -37,6 +37,8 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; + import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.PeerSyncReplicationStateTransitionState; import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.TransitPeerSyncReplicationStateStateData; @@ -50,7 +52,7 @@ public class TransitPeerSyncReplicationStateProcedure private static final Logger LOG = LoggerFactory.getLogger(TransitPeerSyncReplicationStateProcedure.class); - private SyncReplicationState fromState; + protected SyncReplicationState fromState; private SyncReplicationState toState; @@ -107,7 +109,8 @@ protected PeerSyncReplicationStateTransitionState getInitialState() { return PeerSyncReplicationStateTransitionState.PRE_PEER_SYNC_REPLICATION_STATE_TRANSITION; } - private void preTransit(MasterProcedureEnv env) throws IOException { + @VisibleForTesting + protected void preTransit(MasterProcedureEnv env) throws IOException { MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost(); if (cpHost != null) { cpHost.preTransitReplicationPeerSyncReplicationState(peerId, toState); @@ -139,14 +142,15 @@ private void postTransit(MasterProcedureEnv env) throws IOException { } } - private void reopenRegions(MasterProcedureEnv env) { + @VisibleForTesting + protected void reopenRegions(MasterProcedureEnv env) { addChildProcedure( env.getReplicationPeerManager().getPeerConfig(peerId).get().getTableCFsMap().keySet().stream() .map(ReopenTableRegionsProcedure::new).toArray(ReopenTableRegionsProcedure[]::new)); } - private void createDirForRemoteWAL(MasterProcedureEnv env) - throws ProcedureYieldException, IOException { + @VisibleForTesting + protected void createDirForRemoteWAL(MasterProcedureEnv env) throws IOException { MasterFileSystem mfs = env.getMasterFileSystem(); Path remoteWALDir = new Path(mfs.getWALRootDir(), ReplicationUtils.REMOTE_WAL_DIR_NAME); Path remoteWALDirForPeer = ReplicationUtils.getPeerRemoteWALDir(remoteWALDir, peerId); @@ -155,8 +159,7 @@ private void createDirForRemoteWAL(MasterProcedureEnv env) LOG.warn("Wal dir {} already exists, usually this should not happen, continue anyway", remoteWALDirForPeer); } else if (!walFs.mkdirs(remoteWALDirForPeer)) { - LOG.warn("Can not create remote wal dir {}", remoteWALDirForPeer); - throw new ProcedureYieldException(); + throw new IOException("Failed to create remote wal dir " + remoteWALDirForPeer); } } @@ -190,10 +193,33 @@ private void replayRemoteWAL(boolean serial) { addChildProcedure(new RecoverStandbyProcedure(peerId, serial)); } + @VisibleForTesting + protected void setPeerNewSyncReplicationState(MasterProcedureEnv env) + throws ReplicationException { + env.getReplicationPeerManager().setPeerNewSyncReplicationState(peerId, toState); + if (toState.equals(SyncReplicationState.STANDBY) && enabled) { + // disable the peer if we are going to transit to STANDBY state, as we need to remove + // all the pending replication files. If we do not disable the peer and delete the wal + // queues on zk directly, RS will get NoNode exception when updating the wal position + // and crash. + env.getReplicationPeerManager().disablePeer(peerId); + } + } + + @VisibleForTesting + protected void removeAllReplicationQueues(MasterProcedureEnv env) throws ReplicationException { + env.getReplicationPeerManager().removeAllQueues(peerId); + } + + @VisibleForTesting + protected void transitPeerSyncReplicationState(MasterProcedureEnv env) + throws ReplicationException { + env.getReplicationPeerManager().transitPeerSyncReplicationState(peerId, toState); + } + @Override protected Flow executeFromState(MasterProcedureEnv env, - PeerSyncReplicationStateTransitionState state) - throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { + PeerSyncReplicationStateTransitionState state) throws ProcedureSuspendedException { switch (state) { case PRE_PEER_SYNC_REPLICATION_STATE_TRANSITION: try { @@ -209,19 +235,16 @@ protected Flow executeFromState(MasterProcedureEnv env, return Flow.HAS_MORE_STATE; case SET_PEER_NEW_SYNC_REPLICATION_STATE: try { - env.getReplicationPeerManager().setPeerNewSyncReplicationState(peerId, toState); - if (toState.equals(SyncReplicationState.STANDBY) && enabled) { - // disable the peer if we are going to transit to STANDBY state, as we need to remove - // all the pending replication files. If we do not disable the peer and delete the wal - // queues on zk directly, RS will get NoNode exception when updating the wal position - // and crash. - env.getReplicationPeerManager().disablePeer(peerId); - } + setPeerNewSyncReplicationState(env); } catch (ReplicationException e) { - LOG.warn("Failed to update peer storage for peer {} when starting transiting sync " + - "replication peer state from {} to {}, retry", peerId, fromState, toState, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn( + "Failed to update peer storage for peer {} when starting transiting sync " + + "replication peer state from {} to {}, sleep {} secs and retry", + peerId, fromState, toState, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState( PeerSyncReplicationStateTransitionState.REFRESH_PEER_SYNC_REPLICATION_STATE_ON_RS_BEGIN); return Flow.HAS_MORE_STATE; @@ -238,12 +261,16 @@ protected Flow executeFromState(MasterProcedureEnv env, return Flow.HAS_MORE_STATE; case REMOVE_ALL_REPLICATION_QUEUES_IN_PEER: try { - env.getReplicationPeerManager().removeAllQueues(peerId); + removeAllReplicationQueues(env); } catch (ReplicationException e) { - LOG.warn("Failed to remove all replication queues peer {} when starting transiting" + - " sync replication peer state from {} to {}, retry", peerId, fromState, toState, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn( + "Failed to remove all replication queues peer {} when starting transiting" + + " sync replication peer state from {} to {}, sleep {} secs and retry", + peerId, fromState, toState, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState(fromState.equals(SyncReplicationState.ACTIVE) ? PeerSyncReplicationStateTransitionState.REOPEN_ALL_REGIONS_IN_PEER : PeerSyncReplicationStateTransitionState.TRANSIT_PEER_NEW_SYNC_REPLICATION_STATE); @@ -255,12 +282,16 @@ protected Flow executeFromState(MasterProcedureEnv env, return Flow.HAS_MORE_STATE; case TRANSIT_PEER_NEW_SYNC_REPLICATION_STATE: try { - env.getReplicationPeerManager().transitPeerSyncReplicationState(peerId, toState); + transitPeerSyncReplicationState(env); } catch (ReplicationException e) { - LOG.warn("Failed to update peer storage for peer {} when ending transiting sync " + - "replication peer state from {} to {}, retry", peerId, fromState, toState, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn( + "Failed to update peer storage for peer {} when ending transiting sync " + + "replication peer state from {} to {}, sleep {} secs and retry", + peerId, fromState, toState, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState( PeerSyncReplicationStateTransitionState.REFRESH_PEER_SYNC_REPLICATION_STATE_ON_RS_END); return Flow.HAS_MORE_STATE; @@ -272,12 +303,16 @@ protected Flow executeFromState(MasterProcedureEnv env, return Flow.HAS_MORE_STATE; case SYNC_REPLICATION_SET_PEER_ENABLED: try { - env.getReplicationPeerManager().enablePeer(peerId); + enablePeer(env); } catch (ReplicationException e) { - LOG.warn("Failed to set peer enabled for peer {} when transiting sync replication peer " + - "state from {} to {}, retry", peerId, fromState, toState, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn( + "Failed to set peer enabled for peer {} when transiting sync replication peer " + + "state from {} to {}, sleep {} secs and retry", + peerId, fromState, toState, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState( PeerSyncReplicationStateTransitionState.SYNC_REPLICATION_ENABLE_PEER_REFRESH_PEER_ON_RS); return Flow.HAS_MORE_STATE; @@ -289,10 +324,14 @@ protected Flow executeFromState(MasterProcedureEnv env, try { createDirForRemoteWAL(env); } catch (IOException e) { - LOG.warn("Failed to create remote wal dir for peer {} when transiting sync replication " + - "peer state from {} to {}, retry", peerId, fromState, toState, e); - throw new ProcedureYieldException(); + long backoff = ProcedureUtil.getBackoffTimeMs(attempts); + LOG.warn( + "Failed to create remote wal dir for peer {} when transiting sync replication " + + "peer state from {} to {}, sleep {} secs and retry", + peerId, fromState, toState, backoff / 1000, e); + throw suspend(backoff); } + attempts = 0; setNextState( PeerSyncReplicationStateTransitionState.POST_PEER_SYNC_REPLICATION_STATE_TRANSITION); return Flow.HAS_MORE_STATE; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java index 2305ebac96f0..971bb9296309 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/mob/MobCacheConfig.java @@ -42,6 +42,11 @@ public MobCacheConfig(Configuration conf) { instantiateMobFileCache(conf); } + public MobCacheConfig(Configuration conf, boolean needBlockCache) { + super(conf, needBlockCache); + instantiateMobFileCache(conf); + } + /** * Instantiates the MobFileCache. * @param conf The current configuration. diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequester.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequester.java index c54f771395c3..4191fbfb6b5d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequester.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequester.java @@ -32,8 +32,9 @@ public interface FlushRequester { * @param region the Region requesting the cache flush * @param forceFlushAllStores whether we want to flush all stores. e.g., when request from log * rolling. + * @return true if our region is added into the queue, false otherwise */ - void requestFlush(HRegion region, boolean forceFlushAllStores, FlushLifeCycleTracker tracker); + boolean requestFlush(HRegion region, boolean forceFlushAllStores, FlushLifeCycleTracker tracker); /** * Tell the listener the cache needs to be flushed after a delay @@ -42,8 +43,9 @@ public interface FlushRequester { * @param delay after how much time should the flush happen * @param forceFlushAllStores whether we want to flush all stores. e.g., when request from log * rolling. + * @return true if our region is added into the queue, false otherwise */ - void requestDelayedFlush(HRegion region, long delay, boolean forceFlushAllStores); + boolean requestDelayedFlush(HRegion region, long delay, boolean forceFlushAllStores); /** * Register a FlushRequestListener 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 066a0127e254..c10a824b63e0 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 @@ -333,6 +333,9 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi private final int rowLockWaitDuration; static final int DEFAULT_ROWLOCK_WAIT_DURATION = 30000; + private Path regionDir; + private FileSystem walFS; + // The internal wait duration to acquire a lock before read/update // from the region. It is not per row. The purpose of this wait time // is to avoid waiting a long time while the region is busy, so that @@ -947,7 +950,7 @@ private long initializeRegionInternals(final CancelableProgressable reporter, stores.forEach(HStore::startReplayingFromWAL); // Recover any edits if available. maxSeqId = Math.max(maxSeqId, - replayRecoveredEditsIfAny(this.fs.getRegionDir(), maxSeqIdInStores, reporter, status)); + replayRecoveredEditsIfAny(maxSeqIdInStores, reporter, status)); // Make sure mvcc is up to max. this.mvcc.advanceTo(maxSeqId); } finally { @@ -993,14 +996,14 @@ private long initializeRegionInternals(final CancelableProgressable reporter, // Use maximum of log sequenceid or that which was found in stores // (particularly if no recovered edits, seqid will be -1). long maxSeqIdFromFile = - WALSplitter.getMaxRegionSequenceId(fs.getFileSystem(), fs.getRegionDir()); + WALSplitter.getMaxRegionSequenceId(getWalFileSystem(), getWALRegionDir()); long nextSeqId = Math.max(maxSeqId, maxSeqIdFromFile) + 1; // The openSeqNum will always be increase even for read only region, as we rely on it to // determine whether a region has been successfully reopend, so here we always need to update // the max sequence id file. if (RegionReplicaUtil.isDefaultReplica(getRegionInfo())) { LOG.debug("writing seq id for {}", this.getRegionInfo().getEncodedName()); - WALSplitter.writeRegionSequenceIdFile(fs.getFileSystem(), fs.getRegionDir(), nextSeqId - 1); + WALSplitter.writeRegionSequenceIdFile(getWalFileSystem(), getWALRegionDir(), nextSeqId - 1); } LOG.info("Opened {}; next sequenceid={}", this.getRegionInfo().getShortNameToLog(), nextSeqId); @@ -1148,11 +1151,11 @@ RegionEventDescriptor.EventType.REGION_CLOSE, getRegionInfo(), mvcc.getReadPoint WALUtil.writeRegionEventMarker(wal, getReplicationScope(), getRegionInfo(), regionEventDesc, mvcc); - // Store SeqId in HDFS when a region closes + // Store SeqId in WAL FileSystem when a region closes // checking region folder exists is due to many tests which delete the table folder while a // table is still online - if (this.fs.getFileSystem().exists(this.fs.getRegionDir())) { - WALSplitter.writeRegionSequenceIdFile(this.fs.getFileSystem(), this.fs.getRegionDir(), + if (getWalFileSystem().exists(getWALRegionDir())) { + WALSplitter.writeRegionSequenceIdFile(getWalFileSystem(), getWALRegionDir(), mvcc.getReadPoint()); } } @@ -1876,6 +1879,33 @@ public HRegionFileSystem getRegionFileSystem() { return this.fs; } + /** @return the WAL {@link HRegionFileSystem} used by this region */ + HRegionFileSystem getRegionWALFileSystem() throws IOException { + return new HRegionFileSystem(conf, getWalFileSystem(), + FSUtils.getWALTableDir(conf, htableDescriptor.getTableName()), fs.getRegionInfo()); + } + + /** @return the WAL {@link FileSystem} being used by this region */ + FileSystem getWalFileSystem() throws IOException { + if (walFS == null) { + walFS = FSUtils.getWALFileSystem(conf); + } + return walFS; + } + + /** + * @return the Region directory under WALRootDirectory + * @throws IOException if there is an error getting WALRootDir + */ + @VisibleForTesting + public Path getWALRegionDir() throws IOException { + if (regionDir == null) { + regionDir = FSUtils.getWALRegionDir(conf, getRegionInfo().getTable(), + getRegionInfo().getEncodedName()); + } + return regionDir; + } + @Override public long getEarliestFlushTimeForAllStores() { return Collections.min(lastStoreFlushTimeMap.values()); @@ -2828,7 +2858,7 @@ protected FlushResultImpl internalFlushCacheAndCommit(WAL wal, MonitoredTask sta if (rsServices != null && rsServices.getMetrics() != null) { rsServices.getMetrics().updateFlush(getTableDescriptor().getTableName().getNameAsString(), - time - startTime, + time, mss.getDataSize(), flushedOutputFileSize); } @@ -2919,7 +2949,7 @@ public void prepareDelete(Delete delete) throws IOException { if(family == null) { throw new NoSuchColumnFamilyException("Empty family is invalid"); } - checkFamily(family); + checkFamily(family, delete.getDurability()); } } } @@ -3531,7 +3561,7 @@ public void closeRegionOperation() throws IOException { @Override public void checkAndPreparePut(Put p) throws IOException { - region.checkFamilies(p.getFamilyCellMap().keySet()); + region.checkFamilies(p.getFamilyCellMap().keySet(), p.getDurability()); } @Override @@ -4424,14 +4454,30 @@ private void applyToMemStore(HStore store, Cell cell, MemStoreSizing memstoreAcc store.add(cell, memstoreAccounting); } - /** - * Check the collection of families for validity. - * @param families - * @throws NoSuchColumnFamilyException - */ - public void checkFamilies(Collection families) throws NoSuchColumnFamilyException { + private void checkFamilies(Collection families, Durability durability) + throws NoSuchColumnFamilyException, InvalidMutationDurabilityException { for (byte[] family : families) { - checkFamily(family); + checkFamily(family, durability); + } + } + + private void checkFamily(final byte[] family, Durability durability) + throws NoSuchColumnFamilyException, InvalidMutationDurabilityException { + checkFamily(family); + if (durability.equals(Durability.SKIP_WAL) + && htableDescriptor.getColumnFamily(family).getScope() + != HConstants.REPLICATION_SCOPE_LOCAL) { + throw new InvalidMutationDurabilityException( + "Mutation's durability is SKIP_WAL but table's column family " + Bytes.toString(family) + + " need replication"); + } + } + + void checkFamily(final byte[] family) throws NoSuchColumnFamilyException { + if (!this.htableDescriptor.hasColumnFamily(family)) { + throw new NoSuchColumnFamilyException( + "Column family " + Bytes.toString(family) + " does not exist in region " + this + + " in table " + this.htableDescriptor); } } @@ -4505,8 +4551,7 @@ private boolean isFlushSize(MemStoreSize size) { * recovered edits log or minSeqId if nothing added from editlogs. * @throws IOException */ - protected long replayRecoveredEditsIfAny(final Path regiondir, - Map maxSeqIdInStores, + protected long replayRecoveredEditsIfAny(Map maxSeqIdInStores, final CancelableProgressable reporter, final MonitoredTask status) throws IOException { long minSeqIdForTheRegion = -1; @@ -4517,14 +4562,75 @@ protected long replayRecoveredEditsIfAny(final Path regiondir, } long seqid = minSeqIdForTheRegion; - FileSystem fs = this.fs.getFileSystem(); - NavigableSet files = WALSplitter.getSplitEditFilesSorted(fs, regiondir); + FileSystem walFS = getWalFileSystem(); + FileSystem rootFS = getFilesystem(); + Path regionDir = getWALRegionDir(); + Path defaultRegionDir = getRegionDir(FSUtils.getRootDir(conf), getRegionInfo()); + + // This is to ensure backwards compatability with HBASE-20723 where recovered edits can appear + // under the root dir even if walDir is set. + NavigableSet filesUnderRootDir = null; + if (!regionDir.equals(defaultRegionDir)) { + filesUnderRootDir = + WALSplitter.getSplitEditFilesSorted(rootFS, defaultRegionDir); + seqid = Math.max(seqid, + replayRecoveredEditsForPaths(minSeqIdForTheRegion, rootFS, filesUnderRootDir, reporter, + defaultRegionDir)); + } + + NavigableSet files = WALSplitter.getSplitEditFilesSorted(walFS, regionDir); + seqid = Math.max(seqid, replayRecoveredEditsForPaths(minSeqIdForTheRegion, walFS, + files, reporter, regionDir)); + + if (seqid > minSeqIdForTheRegion) { + // Then we added some edits to memory. Flush and cleanup split edit files. + internalFlushcache(null, seqid, stores.values(), status, false, FlushLifeCycleTracker.DUMMY); + } + // Now delete the content of recovered edits. We're done w/ them. + if (files.size() > 0 && this.conf.getBoolean("hbase.region.archive.recovered.edits", false)) { + // For debugging data loss issues! + // If this flag is set, make use of the hfile archiving by making recovered.edits a fake + // column family. Have to fake out file type too by casting our recovered.edits as storefiles + String fakeFamilyName = WALSplitter.getRegionDirRecoveredEditsDir(regionDir).getName(); + Set fakeStoreFiles = new HashSet<>(files.size()); + for (Path file: files) { + fakeStoreFiles.add( + new HStoreFile(walFS, file, this.conf, null, null, true)); + } + getRegionWALFileSystem().removeStoreFiles(fakeFamilyName, fakeStoreFiles); + } else { + if (filesUnderRootDir != null) { + for (Path file : filesUnderRootDir) { + if (!rootFS.delete(file, false)) { + LOG.error("Failed delete of {} from under the root directory.", file); + } else { + LOG.debug("Deleted recovered.edits under root directory. file=" + file); + } + } + } + for (Path file: files) { + if (!walFS.delete(file, false)) { + LOG.error("Failed delete of " + file); + } else { + LOG.debug("Deleted recovered.edits file=" + file); + } + } + } + return seqid; + } + + private long replayRecoveredEditsForPaths(long minSeqIdForTheRegion, FileSystem fs, + final NavigableSet files, final CancelableProgressable reporter, final Path regionDir) + throws IOException { + long seqid = minSeqIdForTheRegion; if (LOG.isDebugEnabled()) { LOG.debug("Found " + (files == null ? 0 : files.size()) - + " recovered edits file(s) under " + regiondir); + + " recovered edits file(s) under " + regionDir); } - if (files == null || files.isEmpty()) return seqid; + if (files == null || files.isEmpty()) { + return minSeqIdForTheRegion; + } for (Path edits: files) { if (edits == null || !fs.exists(edits)) { @@ -4539,8 +4645,8 @@ protected long replayRecoveredEditsIfAny(final Path regiondir, if (maxSeqId <= minSeqIdForTheRegion) { if (LOG.isDebugEnabled()) { String msg = "Maximum sequenceid for this wal is " + maxSeqId - + " and minimum sequenceid for the region is " + minSeqIdForTheRegion - + ", skipped the whole file, path=" + edits; + + " and minimum sequenceid for the region is " + minSeqIdForTheRegion + + ", skipped the whole file, path=" + edits; LOG.debug(msg); } continue; @@ -4549,7 +4655,7 @@ protected long replayRecoveredEditsIfAny(final Path regiondir, try { // replay the edits. Replay can return -1 if everything is skipped, only update // if seqId is greater - seqid = Math.max(seqid, replayRecoveredEdits(edits, maxSeqIdInStores, reporter)); + seqid = Math.max(seqid, replayRecoveredEdits(edits, maxSeqIdInStores, reporter, fs)); } catch (IOException e) { boolean skipErrors = conf.getBoolean( HConstants.HREGION_EDITS_REPLAY_SKIP_ERRORS, @@ -4559,10 +4665,10 @@ protected long replayRecoveredEditsIfAny(final Path regiondir, if (conf.get("hbase.skip.errors") != null) { LOG.warn( "The property 'hbase.skip.errors' has been deprecated. Please use " + - HConstants.HREGION_EDITS_REPLAY_SKIP_ERRORS + " instead."); + HConstants.HREGION_EDITS_REPLAY_SKIP_ERRORS + " instead."); } if (skipErrors) { - Path p = WALSplitter.moveAsideBadEditsFile(fs, edits); + Path p = WALSplitter.moveAsideBadEditsFile(walFS, edits); LOG.error(HConstants.HREGION_EDITS_REPLAY_SKIP_ERRORS + "=true so continuing. Renamed " + edits + " as " + p, e); @@ -4571,31 +4677,6 @@ protected long replayRecoveredEditsIfAny(final Path regiondir, } } } - if (seqid > minSeqIdForTheRegion) { - // Then we added some edits to memory. Flush and cleanup split edit files. - internalFlushcache(null, seqid, stores.values(), status, false, FlushLifeCycleTracker.DUMMY); - } - // Now delete the content of recovered edits. We're done w/ them. - if (files.size() > 0 && this.conf.getBoolean("hbase.region.archive.recovered.edits", false)) { - // For debugging data loss issues! - // If this flag is set, make use of the hfile archiving by making recovered.edits a fake - // column family. Have to fake out file type too by casting our recovered.edits as storefiles - String fakeFamilyName = WALSplitter.getRegionDirRecoveredEditsDir(regiondir).getName(); - Set fakeStoreFiles = new HashSet<>(files.size()); - for (Path file: files) { - fakeStoreFiles.add( - new HStoreFile(getRegionFileSystem().getFileSystem(), file, this.conf, null, null, true)); - } - getRegionFileSystem().removeStoreFiles(fakeFamilyName, fakeStoreFiles); - } else { - for (Path file: files) { - if (!fs.delete(file, false)) { - LOG.error("Failed delete of " + file); - } else { - LOG.debug("Deleted recovered.edits file=" + file); - } - } - } return seqid; } @@ -4609,12 +4690,11 @@ protected long replayRecoveredEditsIfAny(final Path regiondir, * @throws IOException */ private long replayRecoveredEdits(final Path edits, - Map maxSeqIdInStores, final CancelableProgressable reporter) + Map maxSeqIdInStores, final CancelableProgressable reporter, FileSystem fs) throws IOException { String msg = "Replaying edits from " + edits; LOG.info(msg); MonitoredTask status = TaskMonitor.get().createStatus(msg); - FileSystem fs = this.fs.getFileSystem(); status.setStatus("Opening recovered edits"); WAL.Reader reader = null; @@ -4768,7 +4848,7 @@ private long replayRecoveredEdits(final Path edits, coprocessorHost.postReplayWALs(this.getRegionInfo(), edits); } } catch (EOFException eof) { - Path p = WALSplitter.moveAsideBadEditsFile(fs, edits); + Path p = WALSplitter.moveAsideBadEditsFile(walFS, edits); msg = "EnLongAddered EOF. Most likely due to Master failure during " + "wal splitting, so we have this data in another edit. " + "Continuing, but renaming " + edits + " as " + p; @@ -4778,7 +4858,7 @@ private long replayRecoveredEdits(final Path edits, // If the IOE resulted from bad file format, // then this problem is idempotent and retrying won't help if (ioe.getCause() instanceof ParseException) { - Path p = WALSplitter.moveAsideBadEditsFile(fs, edits); + Path p = WALSplitter.moveAsideBadEditsFile(walFS, edits); msg = "File corruption enLongAddered! " + "Continuing, but renaming " + edits + " as " + p; LOG.warn(msg, ioe); @@ -7698,7 +7778,7 @@ private Result doDelta(Operation op, Mutation mutation, long nonceGroup, long no checkReadOnly(); checkResources(); checkRow(mutation.getRow(), op.toString()); - checkFamilies(mutation.getFamilyCellMap().keySet()); + checkFamilies(mutation.getFamilyCellMap().keySet(), mutation.getDurability()); this.writeRequestsCount.increment(); WriteEntry writeEntry = null; startRegionOperation(op); @@ -8048,23 +8128,10 @@ private static List sort(List cells, final CellComparator comparator return cells; } - // - // New HBASE-880 Helpers - // - - void checkFamily(final byte [] family) - throws NoSuchColumnFamilyException { - if (!this.htableDescriptor.hasColumnFamily(family)) { - throw new NoSuchColumnFamilyException("Column family " + - Bytes.toString(family) + " does not exist in region " + this - + " in table " + this.htableDescriptor); - } - } - public static final long FIXED_OVERHEAD = ClassSize.align( ClassSize.OBJECT + ClassSize.ARRAY + - 51 * ClassSize.REFERENCE + 3 * Bytes.SIZEOF_INT + + 53 * ClassSize.REFERENCE + 3 * Bytes.SIZEOF_INT + (15 * Bytes.SIZEOF_LONG) + 3 * Bytes.SIZEOF_BOOLEAN); 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 76175117afd0..7adf58e2b6ee 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 @@ -149,6 +149,8 @@ import org.apache.hadoop.hbase.util.JvmPauseMonitor; import org.apache.hadoop.hbase.util.NettyEventLoopGroupConfig; import org.apache.hadoop.hbase.util.Pair; +import org.apache.hadoop.hbase.util.RetryCounter; +import org.apache.hadoop.hbase.util.RetryCounterFactory; import org.apache.hadoop.hbase.util.ServerRegionReplicaUtil; import org.apache.hadoop.hbase.util.Sleeper; import org.apache.hadoop.hbase.util.Threads; @@ -588,8 +590,11 @@ public HRegionServer(Configuration conf) throws IOException { Superusers.initialize(conf); regionServerAccounting = new RegionServerAccounting(conf); - cacheConfig = new CacheConfig(conf); - mobCacheConfig = new MobCacheConfig(conf); + boolean isMasterNotCarryTable = + this instanceof HMaster && !LoadBalancer.isTablesOnMaster(conf) && !LoadBalancer + .isSystemTablesOnlyOnMaster(conf); + cacheConfig = new CacheConfig(conf, !isMasterNotCarryTable); + mobCacheConfig = new MobCacheConfig(conf, !isMasterNotCarryTable); uncaughtExceptionHandler = new UncaughtExceptionHandler() { @Override public void uncaughtException(Thread t, Throwable e) { @@ -940,14 +945,19 @@ public void run() { this.rsHost = new RegionServerCoprocessorHost(this, this.conf); } - // Try and register with the Master; tell it we are here. Break if - // server is stopped or the clusterup flag is down or hdfs went wacky. - // Once registered successfully, go ahead and start up all Services. + // Try and register with the Master; tell it we are here. Break if server is stopped or the + // clusterup flag is down or hdfs went wacky. Once registered successfully, go ahead and start + // up all Services. Use RetryCounter to get backoff in case Master is struggling to come up. + LOG.debug("About to register with Master."); + RetryCounterFactory rcf = new RetryCounterFactory(Integer.MAX_VALUE, + this.sleeper.getPeriod(), 1000 * 60 * 5); + RetryCounter rc = rcf.create(); while (keepLooping()) { RegionServerStartupResponse w = reportForDuty(); if (w == null) { - LOG.warn("reportForDuty failed; sleeping and then retrying."); - this.sleeper.sleep(); + long sleepTime = rc.getBackoffTimeAndIncrementAttempts(); + LOG.warn("reportForDuty failed; sleeping {} ms and then retrying.", sleepTime); + this.sleeper.sleep(sleepTime); } else { handleReportForDutyResponse(w); break; @@ -1751,11 +1761,16 @@ protected void chore() { static class PeriodicMemStoreFlusher extends ScheduledChore { final HRegionServer server; - final static int RANGE_OF_DELAY = 5 * 60 * 1000; // 5 min in milliseconds + final static int RANGE_OF_DELAY = 5 * 60; // 5 min in seconds final static int MIN_DELAY_TIME = 0; // millisec + + final int rangeOfDelay; public PeriodicMemStoreFlusher(int cacheFlushInterval, final HRegionServer server) { super("MemstoreFlusherChore", server, cacheFlushInterval); this.server = server; + + this.rangeOfDelay = this.server.conf.getInt("hbase.regionserver.periodicmemstoreflusher.rangeofdelayseconds", + RANGE_OF_DELAY)*1000; } @Override @@ -1766,15 +1781,15 @@ protected void chore() { if (r.shouldFlush(whyFlush)) { FlushRequester requester = server.getFlushRequester(); if (requester != null) { - long randomDelay = (long) RandomUtils.nextInt(0, RANGE_OF_DELAY) + MIN_DELAY_TIME; - LOG.info(getName() + " requesting flush of " + - r.getRegionInfo().getRegionNameAsString() + " because " + - whyFlush.toString() + - " after random delay " + randomDelay + "ms"); + long randomDelay = (long) RandomUtils.nextInt(0, rangeOfDelay) + MIN_DELAY_TIME; //Throttle the flushes by putting a delay. If we don't throttle, and there //is a balanced write-load on the regions in a table, we might end up //overwhelming the filesystem with too many flushes at once. - requester.requestDelayedFlush(r, randomDelay, false); + if (requester.requestDelayedFlush(r, randomDelay, false)) { + LOG.info("{} requesting flush of {} because {} after random delay {} ms", + getName(), r.getRegionInfo().getRegionNameAsString(), whyFlush.toString(), + randomDelay); + } } } } @@ -1798,7 +1813,7 @@ public boolean isOnline() { */ private void setupWALAndReplication() throws IOException { boolean isMasterNoTableOrSystemTableOnly = this instanceof HMaster && - (!LoadBalancer.isTablesOnMaster(conf) || LoadBalancer.isSystemTablesOnlyOnMaster(conf)); + !LoadBalancer.isMasterCanHostUserRegions(conf); WALFactory factory = new WALFactory(conf, serverName.toString(), !isMasterNoTableOrSystemTableOnly); if (!isMasterNoTableOrSystemTableOnly) { @@ -2180,8 +2195,7 @@ public void waitForServerOnline(){ } @Override - public void postOpenDeployTasks(final PostOpenDeployContext context) - throws KeeperException, IOException { + public void postOpenDeployTasks(final PostOpenDeployContext context) throws IOException { HRegion r = context.getRegion(); long masterSystemTime = context.getMasterSystemTime(); rpcServices.checkOpen(); @@ -2195,16 +2209,16 @@ public void postOpenDeployTasks(final PostOpenDeployContext context) long openSeqNum = r.getOpenSeqNum(); if (openSeqNum == HConstants.NO_SEQNUM) { // If we opened a region, we should have read some sequence number from it. - LOG.error("No sequence number found when opening " + - r.getRegionInfo().getRegionNameAsString()); + LOG.error( + "No sequence number found when opening " + r.getRegionInfo().getRegionNameAsString()); openSeqNum = 0; } // Notify master - if (!reportRegionStateTransition(new RegionStateTransitionContext( - TransitionCode.OPENED, openSeqNum, masterSystemTime, r.getRegionInfo()))) { - throw new IOException("Failed to report opened region to master: " - + r.getRegionInfo().getRegionNameAsString()); + if (!reportRegionStateTransition(new RegionStateTransitionContext(TransitionCode.OPENED, + openSeqNum, masterSystemTime, r.getRegionInfo()))) { + throw new IOException( + "Failed to report opened region to master: " + r.getRegionInfo().getRegionNameAsString()); } triggerFlushInPrimaryRegion(r); @@ -3602,6 +3616,7 @@ protected ConfigurationManager getConfigurationManager() { /** * @return Return table descriptors implementation. */ + @Override public TableDescriptors getTableDescriptors() { return this.tableDescriptors; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java index 717a466fdb61..032dc5ffd92b 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStore.java @@ -55,6 +55,7 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.fs.permission.FsAction; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellComparator; import org.apache.hadoop.hbase.CellUtil; @@ -302,7 +303,14 @@ protected HStore(final HRegion region, final ColumnFamilyDescriptor family, } this.storeEngine = createStoreEngine(this, this.conf, this.comparator); - this.storeEngine.getStoreFileManager().loadFiles(loadStoreFiles()); + List hStoreFiles = loadStoreFiles(); + // Move the storeSize calculation out of loadStoreFiles() method, because the secondary read + // replica's refreshStoreFiles() will also use loadStoreFiles() to refresh its store files and + // update the storeSize in the completeCompaction(..) finally (just like compaction) , so + // no need calculate the storeSize twice. + this.storeSize.addAndGet(getStorefilesSize(hStoreFiles, sf -> true)); + this.totalUncompressedBytes.addAndGet(getTotalUmcompressedBytes(hStoreFiles)); + this.storeEngine.getStoreFileManager().loadFiles(hStoreFiles); // Initialize checksum type from name. The names are CRC32, CRC32C, etc. this.checksumType = getChecksumType(conf); @@ -324,10 +332,11 @@ protected HStore(final HRegion region, final ColumnFamilyDescriptor family, confPrintThreshold = 10; } this.parallelPutCountPrintThreshold = confPrintThreshold; - LOG.info("Store={}, memstore type={}, storagePolicy={}, verifyBulkLoads={}, " + - "parallelPutCountPrintThreshold={}", getColumnFamilyName(), - this.memstore.getClass().getSimpleName(), policyName, - this.verifyBulkLoads, this.parallelPutCountPrintThreshold); + LOG.info("Store={}, memstore type={}, storagePolicy={}, verifyBulkLoads={}, " + + "parallelPutCountPrintThreshold={}, encoding={}, compression={}", + getColumnFamilyName(), memstore.getClass().getSimpleName(), policyName, verifyBulkLoads, + parallelPutCountPrintThreshold, family.getDataBlockEncoding(), + family.getCompressionType()); } /** @@ -575,10 +584,6 @@ private List openStoreFiles(Collection files) throws try { HStoreFile storeFile = completionService.take().get(); if (storeFile != null) { - long length = storeFile.getReader().length(); - this.storeSize.addAndGet(length); - this.totalUncompressedBytes - .addAndGet(storeFile.getReader().getTotalUncompressedBytes()); LOG.debug("loaded {}", storeFile); results.add(storeFile); } @@ -779,8 +784,9 @@ public void assertBulkLoadHFileOk(Path srcPath) throws IOException { try { LOG.info("Validating hfile at " + srcPath + " for inclusion in " + "store " + this + " region " + this.getRegionInfo().getRegionNameAsString()); - reader = HFile.createReader(srcPath.getFileSystem(conf), srcPath, cacheConf, - isPrimaryReplicaStore(), conf); + FileSystem srcFs = srcPath.getFileSystem(conf); + srcFs.access(srcPath, FsAction.READ_WRITE); + reader = HFile.createReader(srcFs, srcPath, cacheConf, isPrimaryReplicaStore(), conf); reader.loadFileInfo(); Optional firstKey = reader.getFirstRowKey(); @@ -1705,26 +1711,16 @@ public void compactRecentForTestingAssumingDefaultPolicy(int N) throws IOExcepti @Override public boolean hasReferences() { List reloadedStoreFiles = null; + // Grab the read lock here, because we need to ensure that: only when the atomic + // replaceStoreFiles(..) finished, we can get all the complete store file list. + this.lock.readLock().lock(); try { - // Reloading the store files from file system due to HBASE-20940. As split can happen with an - // region which has references - reloadedStoreFiles = loadStoreFiles(); - return StoreUtils.hasReferences(reloadedStoreFiles); - } catch (IOException ioe) { - LOG.error("Error trying to determine if store has references, assuming references exists", - ioe); - return true; + // Merge the current store files with compacted files here due to HBASE-20940. + Collection allStoreFiles = new ArrayList<>(getStorefiles()); + allStoreFiles.addAll(getCompactedFiles()); + return StoreUtils.hasReferences(allStoreFiles); } finally { - if (reloadedStoreFiles != null) { - for (HStoreFile storeFile : reloadedStoreFiles) { - try { - storeFile.closeStoreFile(false); - } catch (IOException ioe) { - LOG.warn("Encountered exception closing " + storeFile + ": " + ioe.getMessage()); - // continue with closing the remaining store files - } - } - } + this.lock.readLock().unlock(); } } @@ -2157,24 +2153,24 @@ public long getStoreSizeUncompressed() { @Override public long getStorefilesSize() { // Include all StoreFiles - return getStorefilesSize(storeFile -> true); + return getStorefilesSize(this.storeEngine.getStoreFileManager().getStorefiles(), sf -> true); } @Override public long getHFilesSize() { // Include only StoreFiles which are HFiles - return getStorefilesSize(storeFile -> storeFile.isHFile()); + return getStorefilesSize(this.storeEngine.getStoreFileManager().getStorefiles(), + HStoreFile::isHFile); } - private long getStorefilesSize(Predicate predicate) { - return this.storeEngine.getStoreFileManager().getStorefiles().stream().filter(sf -> { - if (sf.getReader() == null) { - LOG.warn("StoreFile {} has a null Reader", sf); - return false; - } else { - return true; - } - }).filter(predicate).mapToLong(sf -> sf.getReader().length()).sum(); + private long getTotalUmcompressedBytes(List files) { + return files.stream().filter(f -> f != null && f.getReader() != null) + .mapToLong(f -> f.getReader().getTotalUncompressedBytes()).sum(); + } + + private long getStorefilesSize(Collection files, Predicate predicate) { + return files.stream().filter(f -> f != null && f.getReader() != null).filter(predicate) + .mapToLong(f -> f.getReader().length()).sum(); } private long getStoreFileFieldSize(ToLongFunction f) { @@ -2634,7 +2630,7 @@ private void removeCompactedfiles(Collection compactedfiles, boolean if (storeClosing && !file.isCompactedAway()) { String msg = "Region closing but StoreFile is in compacted list but not compacted away: " + - file.getPath().getName(); + file.getPath(); throw new IllegalStateException(msg); } @@ -2642,8 +2638,8 @@ private void removeCompactedfiles(Collection compactedfiles, boolean //and remove compacted storefiles from the region directory if (file.isCompactedAway() && (!file.isReferencedInReads() || storeClosing)) { if (storeClosing && file.isReferencedInReads()) { - LOG.debug("Region closing but StoreFile still has references: {}", - file.getPath().getName()); + LOG.warn("Region closing but StoreFile still has references: file={}, refCount={}", + file.getPath(), r.getRefCount()); } // Even if deleting fails we need not bother as any new scanners won't be // able to use the compacted file as the status is already compactedAway @@ -2658,13 +2654,13 @@ private void removeCompactedfiles(Collection compactedfiles, boolean storeFileSizes.add(length); } else { LOG.info("Can't archive compacted file " + file.getPath() - + " because of either isCompactedAway = " + file.isCompactedAway() - + " or file has reference, isReferencedInReads = " + file.isReferencedInReads() - + ", skipping for now."); + + " because of either isCompactedAway=" + file.isCompactedAway() + + " or file has reference, isReferencedInReads=" + file.isReferencedInReads() + + ", refCount=" + r.getRefCount() + ", skipping for now."); } } catch (Exception e) { String msg = "Exception while trying to close the compacted store file " + - file.getPath().getName(); + file.getPath(); if (storeClosing) { msg = "Store is closing. " + msg; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStoreFile.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStoreFile.java index 4a0c66f50156..4aff949c6f73 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStoreFile.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HStoreFile.java @@ -86,6 +86,9 @@ public class HStoreFile implements StoreFile, StoreFileReader.Listener { /** Bloom filter Type in FileInfo */ public static final byte[] BLOOM_FILTER_TYPE_KEY = Bytes.toBytes("BLOOM_FILTER_TYPE"); + /** Bloom filter param in FileInfo */ + public static final byte[] BLOOM_FILTER_PARAM_KEY = Bytes.toBytes("BLOOM_FILTER_PARAM"); + /** Delete Family Count in FileInfo */ public static final byte[] DELETE_FAMILY_COUNT = Bytes.toBytes("DELETE_FAMILY_COUNT"); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java index 2a49797e52cb..699c9b6b0e69 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MemStoreFlusher.java @@ -460,8 +460,8 @@ private FlushType isAboveLowWaterMark() { } @Override - public void requestFlush(HRegion r, boolean forceFlushAllStores, FlushLifeCycleTracker tracker) { - r.incrementFlushesQueuedCount(); + public boolean requestFlush(HRegion r, boolean forceFlushAllStores, + FlushLifeCycleTracker tracker) { synchronized (regionsInQueue) { if (!regionsInQueue.containsKey(r)) { // This entry has no delay so it will be added at the top of the flush @@ -469,15 +469,17 @@ public void requestFlush(HRegion r, boolean forceFlushAllStores, FlushLifeCycleT FlushRegionEntry fqe = new FlushRegionEntry(r, forceFlushAllStores, tracker); this.regionsInQueue.put(r, fqe); this.flushQueue.add(fqe); + r.incrementFlushesQueuedCount(); + return true; } else { tracker.notExecuted("Flush already requested on " + r); + return false; } } } @Override - public void requestDelayedFlush(HRegion r, long delay, boolean forceFlushAllStores) { - r.incrementFlushesQueuedCount(); + public boolean requestDelayedFlush(HRegion r, long delay, boolean forceFlushAllStores) { synchronized (regionsInQueue) { if (!regionsInQueue.containsKey(r)) { // This entry has some delay @@ -486,7 +488,10 @@ public void requestDelayedFlush(HRegion r, long delay, boolean forceFlushAllStor fqe.requeue(delay); this.regionsInQueue.put(r, fqe); this.flushQueue.add(fqe); + r.incrementFlushesQueuedCount(); + return true; } + return false; } } 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 cb97d351377c..17c582df672f 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 @@ -20,6 +20,7 @@ import java.io.FileNotFoundException; import java.io.IOException; import java.io.InterruptedIOException; +import java.io.UncheckedIOException; import java.lang.reflect.InvocationTargetException; import java.net.BindException; import java.net.InetSocketAddress; @@ -118,9 +119,11 @@ import org.apache.hadoop.hbase.regionserver.Region.Operation; import org.apache.hadoop.hbase.regionserver.ScannerContext.LimitScope; import org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker; +import org.apache.hadoop.hbase.regionserver.handler.AssignRegionHandler; import org.apache.hadoop.hbase.regionserver.handler.OpenMetaHandler; import org.apache.hadoop.hbase.regionserver.handler.OpenPriorityRegionHandler; import org.apache.hadoop.hbase.regionserver.handler.OpenRegionHandler; +import org.apache.hadoop.hbase.regionserver.handler.UnassignRegionHandler; import org.apache.hadoop.hbase.replication.ReplicationUtils; import org.apache.hadoop.hbase.replication.regionserver.RejectReplicationRequestStateChecker; import org.apache.hadoop.hbase.replication.regionserver.RejectRequestsFromClientStateChecker; @@ -2482,8 +2485,10 @@ private com.google.protobuf.Message execServiceOnRegion(HRegion region, } private boolean shouldRejectRequestsFromClient(HRegion region) { - return regionServer.getReplicationSourceService().getSyncReplicationPeerInfoProvider() - .checkState(region.getRegionInfo().getTable(), RejectRequestsFromClientStateChecker.get()); + TableName table = region.getRegionInfo().getTable(); + ReplicationSourceService service = regionServer.getReplicationSourceService(); + return service != null && service.getSyncReplicationPeerInfoProvider() + .checkState(table, RejectRequestsFromClientStateChecker.get()); } private void rejectIfInStandByState(HRegion region) throws DoNotRetryIOException { @@ -3282,6 +3287,18 @@ private void scan(HBaseRpcController controller, ScanRequest request, RegionScan break; } } + } else if (!moreRows && !results.isEmpty()) { + // No more cells for the scan here, we need to ensure that the mayHaveMoreCellsInRow of + // last result is false. Otherwise it's possible that: the first nextRaw returned + // because BATCH_LIMIT_REACHED (BTW it happen to exhaust all cells of the scan),so the + // last result's mayHaveMoreCellsInRow will be true. while the following nextRaw will + // return with moreRows=false, which means moreResultsInRegion would be false, it will + // be a contradictory state (HBASE-21206). + int lastIdx = results.size() - 1; + Result r = results.get(lastIdx); + if (r.mayHaveMoreCellsInRow()) { + results.set(lastIdx, Result.create(r.rawCells(), r.getExists(), r.isStale(), false)); + } } boolean sizeLimitReached = scannerContext.checkSizeLimit(LimitScope.BETWEEN_ROWS); boolean timeLimitReached = scannerContext.checkTimeLimit(LimitScope.BETWEEN_ROWS); @@ -3297,12 +3314,12 @@ private void scan(HBaseRpcController controller, ScanRequest request, RegionScan // there are more values to be read server side. If there aren't more values, // marking it as a heartbeat is wasteful because the client will need to issue // another ScanRequest only to realize that they already have all the values - if (moreRows) { + if (moreRows && timeLimitReached) { // Heartbeat messages occur when the time limit has been reached. - builder.setHeartbeatMessage(timeLimitReached); - if (timeLimitReached && rsh.needCursor) { + builder.setHeartbeatMessage(true); + if (rsh.needCursor) { Cell cursorCell = scannerContext.getLastPeekedCell(); - if (cursorCell != null ) { + if (cursorCell != null) { builder.setCursor(ProtobufUtil.toCursor(cursorCell)); } } @@ -3670,6 +3687,60 @@ public ClearRegionBlockCacheResponse clearRegionBlockCache(RpcController control return builder.setStats(ProtobufUtil.toCacheEvictionStats(stats.build())).build(); } + private void executeOpenRegionProcedures(OpenRegionRequest request, + Map tdCache) { + long masterSystemTime = request.hasMasterSystemTime() ? request.getMasterSystemTime() : -1; + for (RegionOpenInfo regionOpenInfo : request.getOpenInfoList()) { + RegionInfo regionInfo = ProtobufUtil.toRegionInfo(regionOpenInfo.getRegion()); + TableDescriptor tableDesc = tdCache.get(regionInfo.getTable()); + if (tableDesc == null) { + try { + tableDesc = regionServer.getTableDescriptors().get(regionInfo.getTable()); + } catch (IOException e) { + // Here we do not fail the whole method since we also need deal with other + // procedures, and we can not ignore this one, so we still schedule a + // AssignRegionHandler and it will report back to master if we still can not get the + // TableDescriptor. + LOG.warn("Failed to get TableDescriptor of {}, will try again in the handler", + regionInfo.getTable(), e); + } + } + if (regionOpenInfo.getFavoredNodesCount() > 0) { + regionServer.updateRegionFavoredNodesMapping(regionInfo.getEncodedName(), + regionOpenInfo.getFavoredNodesList()); + } + regionServer.executorService + .submit(AssignRegionHandler.create(regionServer, regionInfo, tableDesc, masterSystemTime)); + } + } + + private void executeCloseRegionProcedures(CloseRegionRequest request) { + String encodedName; + try { + encodedName = ProtobufUtil.getRegionEncodedName(request.getRegion()); + } catch (DoNotRetryIOException e) { + throw new UncheckedIOException("Should not happen", e); + } + ServerName destination = + request.hasDestinationServer() ? ProtobufUtil.toServerName(request.getDestinationServer()) + : null; + regionServer.executorService + .submit(UnassignRegionHandler.create(regionServer, encodedName, false, destination)); + } + + private void executeProcedures(RemoteProcedureRequest request) { + RSProcedureCallable callable; + try { + callable = Class.forName(request.getProcClass()).asSubclass(RSProcedureCallable.class) + .getDeclaredConstructor().newInstance(); + } catch (Exception e) { + regionServer.remoteProcedureComplete(request.getProcId(), e); + return; + } + callable.init(request.getProcData().toByteArray(), regionServer); + regionServer.executeProcedure(request.getProcId(), callable); + } + @Override @QosPriority(priority = HConstants.ADMIN_QOS) public ExecuteProceduresResponse executeProcedures(RpcController controller, @@ -3678,28 +3749,16 @@ public ExecuteProceduresResponse executeProcedures(RpcController controller, checkOpen(); regionServer.getRegionServerCoprocessorHost().preExecuteProcedures(); if (request.getOpenRegionCount() > 0) { - for (OpenRegionRequest req : request.getOpenRegionList()) { - openRegion(controller, req); - } + // Avoid reading from the TableDescritor every time(usually it will read from the file + // system) + Map tdCache = new HashMap<>(); + request.getOpenRegionList().forEach(req -> executeOpenRegionProcedures(req, tdCache)); } if (request.getCloseRegionCount() > 0) { - for (CloseRegionRequest req : request.getCloseRegionList()) { - closeRegion(controller, req); - } + request.getCloseRegionList().forEach(this::executeCloseRegionProcedures); } if (request.getProcCount() > 0) { - for (RemoteProcedureRequest req : request.getProcList()) { - RSProcedureCallable callable; - try { - callable = Class.forName(req.getProcClass()).asSubclass(RSProcedureCallable.class) - .getDeclaredConstructor().newInstance(); - } catch (Exception e) { - regionServer.remoteProcedureComplete(req.getProcId(), e); - continue; - } - callable.init(req.getProcData().toByteArray(), regionServer); - regionServer.executeProcedure(req.getProcId(), callable); - } + request.getProcList().forEach(this::executeProcedures); } regionServer.getRegionServerCoprocessorHost().postExecuteProcedures(); return ExecuteProceduresResponse.getDefaultInstance(); 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 7c4362c68fbc..37a3606ede5d 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 @@ -18,14 +18,15 @@ */ package org.apache.hadoop.hbase.regionserver; +import com.google.protobuf.Service; import java.io.IOException; import java.util.Collection; import java.util.List; import java.util.Map.Entry; import java.util.concurrent.ConcurrentMap; - import org.apache.hadoop.hbase.Abortable; import org.apache.hadoop.hbase.Server; +import org.apache.hadoop.hbase.TableDescriptors; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.locking.EntityLock; @@ -38,12 +39,9 @@ import org.apache.hadoop.hbase.regionserver.throttle.ThroughputController; import org.apache.hadoop.hbase.wal.WAL; import org.apache.yetus.audience.InterfaceAudience; -import org.apache.zookeeper.KeeperException; import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode; -import com.google.protobuf.Service; - /** * A curated subset of services provided by {@link HRegionServer}. * For use internally only. Passed to Managers, Services and Chores so can pass less-than-a @@ -115,14 +113,10 @@ public long getMasterSystemTime() { } /** - * Tasks to perform after region open to complete deploy of region on - * regionserver - * + * Tasks to perform after region open to complete deploy of region on regionserver * @param context the context - * @throws KeeperException - * @throws IOException */ - void postOpenDeployTasks(final PostOpenDeployContext context) throws KeeperException, IOException; + void postOpenDeployTasks(final PostOpenDeployContext context) throws IOException; class RegionStateTransitionContext { private final TransitionCode code; @@ -267,4 +261,9 @@ boolean reportFileArchivalForQuotas( * @return Return the object that implements the replication source executorService. */ ReplicationSourceService getReplicationSourceService(); + + /** + * @return Return table descriptors implementation. + */ + TableDescriptors getTableDescriptors(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java index a4ee517fd69b..566a6b688f3c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SecureBulkLoadManager.java @@ -25,6 +25,9 @@ import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.concurrent.ConcurrentHashMap; +import java.util.function.BiFunction; +import java.util.function.Consumer; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileStatus; @@ -53,6 +56,7 @@ import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; +import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.BulkLoadHFileRequest; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CleanupBulkLoadRequest; @@ -106,6 +110,7 @@ public class SecureBulkLoadManager { private Path baseStagingDir; private UserProvider userProvider; + private ConcurrentHashMap ugiReferenceCounter; private Connection conn; SecureBulkLoadManager(Configuration conf, Connection conn) { @@ -116,6 +121,7 @@ public class SecureBulkLoadManager { public void start() throws IOException { random = new SecureRandom(); userProvider = UserProvider.instantiate(conf); + ugiReferenceCounter = new ConcurrentHashMap<>(); fs = FileSystem.get(conf); baseStagingDir = new Path(FSUtils.getRootDir(conf), HConstants.BULKLOAD_STAGING_DIR_NAME); @@ -158,7 +164,7 @@ public void cleanupBulkLoad(final HRegion region, final CleanupBulkLoadRequest r } finally { UserGroupInformation ugi = getActiveUser().getUGI(); try { - if (!UserGroupInformation.getLoginUser().equals(ugi)) { + if (!UserGroupInformation.getLoginUser().equals(ugi) && !isUserReferenced(ugi)) { FileSystem.closeAllForUGI(ugi); } } catch (IOException e) { @@ -167,6 +173,38 @@ public void cleanupBulkLoad(final HRegion region, final CleanupBulkLoadRequest r } } + private Consumer fsCreatedListener; + + @VisibleForTesting + void setFsCreatedListener(Consumer fsCreatedListener) { + this.fsCreatedListener = fsCreatedListener; + } + + + private void incrementUgiReference(UserGroupInformation ugi) { + ugiReferenceCounter.merge(ugi, 1, new BiFunction() { + @Override + public Integer apply(Integer oldvalue, Integer value) { + return ++oldvalue; + } + }); + } + + private void decrementUgiReference(UserGroupInformation ugi) { + ugiReferenceCounter.computeIfPresent(ugi, + new BiFunction() { + @Override + public Integer apply(UserGroupInformation key, Integer value) { + return value > 1 ? --value : null; + } + }); + } + + private boolean isUserReferenced(UserGroupInformation ugi) { + Integer count = ugiReferenceCounter.get(ugi); + return count != null && count > 0; + } + public Map> secureBulkLoadHFiles(final HRegion region, final BulkLoadHFileRequest request) throws IOException { final List> familyPaths = new ArrayList<>(request.getFamilyPathCount()); @@ -208,6 +246,7 @@ public Map> secureBulkLoadHFiles(final HRegion region, Map> map = null; try { + incrementUgiReference(ugi); // Get the target fs (HBase region server fs) delegation token // Since we have checked the permission via 'preBulkLoadHFile', now let's give // the 'request user' necessary token to operate on the target fs. @@ -237,6 +276,9 @@ public Map> run() { fs.setPermission(stageFamily, PERM_ALL_ACCESS); } } + if (fsCreatedListener != null) { + fsCreatedListener.accept(region); + } //We call bulkLoadHFiles as requesting user //To enable access prior to staging return region.bulkLoadHFiles(familyPaths, true, @@ -248,6 +290,7 @@ public Map> run() { } }); } finally { + decrementUgiReference(ugi); if (region.getCoprocessorHost() != null) { region.getCoprocessorHost().postBulkLoadHFile(familyPaths, map); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SegmentScanner.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SegmentScanner.java index 8a867b67b9a3..ec1ec0b47220 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SegmentScanner.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SegmentScanner.java @@ -49,6 +49,8 @@ public class SegmentScanner implements KeyValueScanner { // A flag represents whether could stop skipping KeyValues for MVCC // if have encountered the next row. Only used for reversed scan private boolean stopSkippingKVsIfNextRow = false; + // Stop skipping KeyValues for MVCC if finish this row. Only used for reversed scan + private Cell stopSkippingKVsRow; // last iterated KVs by seek (to restore the iterator state after reseek) private Cell last = null; @@ -203,6 +205,7 @@ public boolean seekToPreviousRow(Cell cell) throws IOException { } Cell firstKeyOnPreviousRow = PrivateCellUtil.createFirstOnRow(lastCellBeforeRow); this.stopSkippingKVsIfNextRow = true; + this.stopSkippingKVsRow = firstKeyOnPreviousRow; seek(firstKeyOnPreviousRow); this.stopSkippingKVsIfNextRow = false; if (peek() == null @@ -344,7 +347,6 @@ private Segment getSegment(){ * skipping the cells with irrelevant MVCC */ protected void updateCurrent() { - Cell startKV = current; Cell next = null; try { @@ -354,9 +356,9 @@ protected void updateCurrent() { current = next; return;// skip irrelevant versions } - if (stopSkippingKVsIfNextRow && // for backwardSeek() stay in the - startKV != null && // boundaries of a single row - segment.compareRows(next, startKV) > 0) { + // for backwardSeek() stay in the boundaries of a single row + if (stopSkippingKVsIfNextRow && + segment.compareRows(next, stopSkippingKVsRow) > 0) { current = null; return; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileReader.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileReader.java index 9080c2db84ad..3fbddf21a7d5 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileReader.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileReader.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hbase.regionserver; +import static org.apache.hadoop.hbase.regionserver.HStoreFile.BLOOM_FILTER_PARAM_KEY; import static org.apache.hadoop.hbase.regionserver.HStoreFile.BLOOM_FILTER_TYPE_KEY; import static org.apache.hadoop.hbase.regionserver.HStoreFile.DELETE_FAMILY_COUNT; import static org.apache.hadoop.hbase.regionserver.HStoreFile.LAST_BLOOM_KEY; @@ -74,6 +75,8 @@ public class StoreFileReader { private boolean bulkLoadResult = false; private KeyValue.KeyOnlyKeyValue lastBloomKeyOnlyKV = null; private boolean skipResetSeqId = true; + private int prefixLength = -1; + private byte[] delimiter = null; // Counter that is incremented every time a scanner is created on the // store file. It is decremented when the scan on the store file is @@ -119,6 +122,8 @@ void copyFields(StoreFileReader reader) { this.bulkLoadResult = reader.bulkLoadResult; this.lastBloomKeyOnlyKV = reader.lastBloomKeyOnlyKV; this.skipResetSeqId = reader.skipResetSeqId; + this.prefixLength = reader.prefixLength; + this.delimiter = reader.delimiter; } public boolean isPrimaryReplicaReader() { @@ -156,6 +161,14 @@ public StoreFileScanner getStoreFileScanner(boolean cacheBlocks, boolean pread, !isCompaction, reader.hasMVCCInfo(), readPt, scannerOrder, canOptimizeForNonNullColumn); } + /** + * Return the ref count associated with the reader whenever a scanner associated with the + * reader is opened. + */ + int getRefCount() { + return refCount.get(); + } + /** * Indicate that the scanner has started reading with this reader. We need to increment the ref * count so reader is not close until some object is holding the lock @@ -228,7 +241,7 @@ public void close(boolean evictOnClose) throws IOException { /** * Check if this storeFile may contain keys within the TimeRange that * have not expired (i.e. not older than oldestUnexpiredTS). - * @param timeRange the timeRange to restrict + * @param tr the timeRange to restrict * @param oldestUnexpiredTS the oldest timestamp that is not expired, as * determined by the column family's TTL * @return false if queried keys definitely don't exist in this StoreFile @@ -255,18 +268,18 @@ boolean passesTimerangeFilter(TimeRange tr, long oldestUnexpiredTS) { * False if the Bloom filter is applicable and the scan fails it. */ boolean passesBloomFilter(Scan scan, final SortedSet columns) { - // Multi-column non-get scans will use Bloom filters through the - // lower-level API function that this function calls. - if (!scan.isGetScan()) { - return true; - } - byte[] row = scan.getStartRow(); switch (this.bloomFilterType) { case ROW: + if (!scan.isGetScan()) { + return true; + } return passesGeneralRowBloomFilter(row, 0, row.length); case ROWCOL: + if (!scan.isGetScan()) { + return true; + } if (columns != null && columns.size() == 1) { byte[] column = columns.first(); // create the required fake key @@ -277,7 +290,10 @@ boolean passesBloomFilter(Scan scan, final SortedSet columns) { // For multi-column queries the Bloom filter is checked from the // seekExact operation. return true; - + case ROWPREFIX_FIXED_LENGTH: + return passesGeneralRowPrefixBloomFilter(scan); + case ROWPREFIX_DELIMITED: + return passesGeneralDelimitedRowPrefixBloomFilter(scan); default: return true; } @@ -318,7 +334,7 @@ public boolean passesDeleteFamilyBloomFilter(byte[] row, int rowOffset, * * @return True if passes */ - public boolean passesGeneralRowBloomFilter(byte[] row, int rowOffset, int rowLen) { + private boolean passesGeneralRowBloomFilter(byte[] row, int rowOffset, int rowLen) { BloomFilter bloomFilter = this.generalBloomFilter; if (bloomFilter == null) { return true; @@ -328,7 +344,7 @@ public boolean passesGeneralRowBloomFilter(byte[] row, int rowOffset, int rowLen byte[] key = null; if (rowOffset != 0 || rowLen != row.length) { throw new AssertionError( - "For row-only Bloom filters the row " + "must occupy the whole array"); + "For row-only Bloom filters the row must occupy the whole array"); } key = row; return checkGeneralBloomFilter(key, null, bloomFilter); @@ -358,6 +374,76 @@ public boolean passesGeneralRowColBloomFilter(Cell cell) { return checkGeneralBloomFilter(null, kvKey, bloomFilter); } + /** + * A method for checking Bloom filters. Called directly from + * StoreFileScanner in case of a multi-column query. + * + * @return True if passes + */ + private boolean passesGeneralRowPrefixBloomFilter(Scan scan) { + BloomFilter bloomFilter = this.generalBloomFilter; + if (bloomFilter == null) { + return true; + } + + byte[] row = scan.getStartRow(); + byte[] rowPrefix; + if (scan.isGetScan()) { + rowPrefix = Bytes.copy(row, 0, Math.min(prefixLength, row.length)); + } else { + // For non-get scans + // Find out the common prefix of startRow and stopRow. + int commonLength = Bytes.findCommonPrefix(scan.getStartRow(), scan.getStopRow(), + scan.getStartRow().length, scan.getStopRow().length, 0, 0); + // startRow and stopRow don't have the common prefix. + // Or the common prefix length is less than prefixLength + if (commonLength <= 0 || commonLength < prefixLength) { + return true; + } + rowPrefix = Bytes.copy(row, 0, prefixLength); + } + return checkGeneralBloomFilter(rowPrefix, null, bloomFilter); + } + + /** + * A method for checking Bloom filters. Called directly from + * StoreFileScanner in case of a multi-column query. + * + * @return True if passes + */ + private boolean passesGeneralDelimitedRowPrefixBloomFilter(Scan scan) { + BloomFilter bloomFilter = this.generalBloomFilter; + if (bloomFilter == null) { + return true; + } + + byte[] row = scan.getStartRow(); + byte[] rowPrefix; + if (scan.isGetScan()) { + int rowPrefixLength = Bytes.indexOf(row, delimiter); + if (rowPrefixLength <= 0) { + rowPrefix = row; + } else { + rowPrefix = Bytes.copy(row, 0, rowPrefixLength); + } + } else { + // For non-get scans + // If startRow does not contain delimiter, return true directly. + int startRowPrefixLength = Bytes.indexOf(row, delimiter); + if (startRowPrefixLength <= 0) { + return true; + } + // If stopRow does not have the same prefix as startRow, return true directly. + int commonLength = Bytes.findCommonPrefix(scan.getStartRow(), scan.getStopRow(), + startRowPrefixLength, scan.getStopRow().length, 0, 0); + if (commonLength < startRowPrefixLength) { + return true; + } + rowPrefix = Bytes.copy(row, 0, startRowPrefixLength); + } + return checkGeneralBloomFilter(rowPrefix, null, bloomFilter); + } + private boolean checkGeneralBloomFilter(byte[] key, Cell kvKey, BloomFilter bloomFilter) { // Empty file if (reader.getTrailer().getEntryCount() == 0) { @@ -386,10 +472,10 @@ private boolean checkGeneralBloomFilter(byte[] key, Cell kvKey, BloomFilter bloo // hbase:meta does not have blooms. So we need not have special interpretation // of the hbase:meta cells. We can safely use Bytes.BYTES_RAWCOMPARATOR for ROW Bloom if (keyIsAfterLast) { - if (bloomFilterType == BloomType.ROW) { - keyIsAfterLast = (Bytes.BYTES_RAWCOMPARATOR.compare(key, lastBloomKey) > 0); - } else { + if (bloomFilterType == BloomType.ROWCOL) { keyIsAfterLast = (CellComparator.getInstance().compare(kvKey, lastBloomKeyOnlyKV)) > 0; + } else { + keyIsAfterLast = (Bytes.BYTES_RAWCOMPARATOR.compare(key, lastBloomKey) > 0); } } @@ -465,6 +551,13 @@ public Map loadFileInfo() throws IOException { bloomFilterType = BloomType.valueOf(Bytes.toString(b)); } + byte[] p = fi.get(BLOOM_FILTER_PARAM_KEY); + if (bloomFilterType == BloomType.ROWPREFIX_FIXED_LENGTH) { + prefixLength = Bytes.toInt(p); + } else if (bloomFilterType == BloomType.ROWPREFIX_DELIMITED) { + delimiter = p; + } + lastBloomKey = fi.get(LAST_BLOOM_KEY); if(bloomFilterType == BloomType.ROWCOL) { lastBloomKeyOnlyKV = new KeyValue.KeyOnlyKeyValue(lastBloomKey, 0, lastBloomKey.length); @@ -665,4 +758,13 @@ public void setListener(Listener listener) { public interface Listener { void storeFileReaderClosed(StoreFileReader reader); } + + + public int getPrefixLength() { + return prefixLength; + } + + public byte[] getDelimiter() { + return delimiter; + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileWriter.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileWriter.java index 2782e6f5d082..b31df395344a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileWriter.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StoreFileWriter.java @@ -17,6 +17,7 @@ */ package org.apache.hadoop.hbase.regionserver; +import static org.apache.hadoop.hbase.regionserver.HStoreFile.BLOOM_FILTER_PARAM_KEY; import static org.apache.hadoop.hbase.regionserver.HStoreFile.BLOOM_FILTER_TYPE_KEY; import static org.apache.hadoop.hbase.regionserver.HStoreFile.DELETE_FAMILY_COUNT; import static org.apache.hadoop.hbase.regionserver.HStoreFile.EARLIEST_PUT_TS; @@ -44,11 +45,14 @@ import org.apache.hadoop.hbase.io.hfile.HFileContext; import org.apache.hadoop.hbase.util.BloomContext; import org.apache.hadoop.hbase.util.BloomFilterFactory; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.BloomFilterWriter; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.FSUtils; import org.apache.hadoop.hbase.util.RowBloomContext; import org.apache.hadoop.hbase.util.RowColBloomContext; +import org.apache.hadoop.hbase.util.RowPrefixDelimiterBloomContext; +import org.apache.hadoop.hbase.util.RowPrefixFixedLengthBloomContext; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -65,6 +69,7 @@ public class StoreFileWriter implements CellSink, ShipperListener { private final BloomFilterWriter generalBloomFilterWriter; private final BloomFilterWriter deleteFamilyBloomFilterWriter; private final BloomType bloomType; + private byte[] bloomParam = null; private long earliestPutTs = HConstants.LATEST_TIMESTAMP; private long deleteFamilyCnt = 0; private BloomContext bloomContext = null; @@ -110,21 +115,32 @@ private StoreFileWriter(FileSystem fs, Path path, if (generalBloomFilterWriter != null) { this.bloomType = bloomType; + this.bloomParam = BloomFilterUtil.getBloomFilterParam(bloomType, conf); if (LOG.isTraceEnabled()) { - LOG.trace("Bloom filter type for " + path + ": " + this.bloomType + ", " + - generalBloomFilterWriter.getClass().getSimpleName()); + LOG.trace("Bloom filter type for " + path + ": " + this.bloomType + ", param: " + + (bloomType == BloomType.ROWPREFIX_FIXED_LENGTH? + Bytes.toInt(bloomParam):Bytes.toStringBinary(bloomParam)) + + ", " + generalBloomFilterWriter.getClass().getSimpleName()); } // init bloom context switch (bloomType) { - case ROW: - bloomContext = new RowBloomContext(generalBloomFilterWriter, comparator); - break; - case ROWCOL: - bloomContext = new RowColBloomContext(generalBloomFilterWriter, comparator); - break; - default: - throw new IOException( - "Invalid Bloom filter type: " + bloomType + " (ROW or ROWCOL expected)"); + case ROW: + bloomContext = new RowBloomContext(generalBloomFilterWriter, comparator); + break; + case ROWCOL: + bloomContext = new RowColBloomContext(generalBloomFilterWriter, comparator); + break; + case ROWPREFIX_FIXED_LENGTH: + bloomContext = new RowPrefixFixedLengthBloomContext(generalBloomFilterWriter, comparator, + Bytes.toInt(bloomParam)); + break; + case ROWPREFIX_DELIMITED: + bloomContext = new RowPrefixDelimiterBloomContext(generalBloomFilterWriter, comparator, + bloomParam); + break; + default: + throw new IOException("Invalid Bloom filter type: " + + bloomType + " (ROW or ROWCOL or ROWPREFIX or ROWPREFIX_DELIMITED expected)"); } } else { // Not using Bloom filters. @@ -206,9 +222,11 @@ private void appendGeneralBloomfilter(final Cell cell) throws IOException { * http://2.bp.blogspot.com/_Cib_A77V54U/StZMrzaKufI/AAAAAAAAADo/ZhK7bGoJdMQ/s400/KeyValue.png * Key = RowLen + Row + FamilyLen + Column [Family + Qualifier] + Timestamp * - * 2 Types of Filtering: + * 4 Types of Filtering: * 1. Row = Row * 2. RowCol = Row + Qualifier + * 3. RowPrefixFixedLength = Fixed Length Row Prefix + * 4. RowPrefixDelimiter = Delimited Row Prefix */ bloomContext.writeBloom(cell); } @@ -280,6 +298,9 @@ private boolean closeGeneralBloomFilter() throws IOException { if (hasGeneralBloom) { writer.addGeneralBloomFilter(generalBloomFilterWriter); writer.appendFileInfo(BLOOM_FILTER_TYPE_KEY, Bytes.toBytes(bloomType.toString())); + if (bloomParam != null) { + writer.appendFileInfo(BLOOM_FILTER_PARAM_KEY, bloomParam); + } bloomContext.addLastBloomKey(writer); } return hasGeneralBloom; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java index d6e55105fcb3..83690a95c7ef 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/compactions/Compactor.java @@ -199,12 +199,14 @@ private FileDetails getFileDetails( } tmp = fileInfo.get(TIMERANGE_KEY); fd.latestPutTs = tmp == null ? HConstants.LATEST_TIMESTAMP: TimeRangeTracker.parseFrom(tmp).getMax(); - LOG.debug("Compacting {}, keycount={}, bloomtype={}, size={}, encoding={}, seqNum={}{}", + LOG.debug("Compacting {}, keycount={}, bloomtype={}, size={}, " + + "encoding={}, compression={}, seqNum={}{}", (file.getPath() == null? null: file.getPath().getName()), keyCount, r.getBloomFilterType().toString(), TraditionalBinaryPrefix.long2String(r.length(), "", 1), r.getHFileReader().getDataBlockEncoding(), + compactionCompression, seqNum, (allFiles? ", earliestPutTs=" + earliestPutTs: "")); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/AssignRegionHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/AssignRegionHandler.java new file mode 100644 index 000000000000..c6fee2e57ae1 --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/AssignRegionHandler.java @@ -0,0 +1,171 @@ +/** + * 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.regionserver.handler; + +import edu.umd.cs.findbugs.annotations.Nullable; +import java.io.IOException; +import java.util.concurrent.TimeUnit; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.executor.EventHandler; +import org.apache.hadoop.hbase.executor.EventType; +import org.apache.hadoop.hbase.regionserver.HRegion; +import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.RegionServerServices; +import org.apache.hadoop.hbase.regionserver.RegionServerServices.PostOpenDeployContext; +import org.apache.hadoop.hbase.regionserver.RegionServerServices.RegionStateTransitionContext; +import org.apache.hadoop.hbase.util.RetryCounter; +import org.apache.yetus.audience.InterfaceAudience; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode; + +/** + * Handles opening of a region on a region server. + *

    + * Just done the same thing with the old {@link OpenRegionHandler}, with some modifications on + * fencing and retrying. But we need to keep the {@link OpenRegionHandler} as is to keep compatible + * with the zk less assignment for 1.x, otherwise it is not possible to do rolling upgrade. + */ +@InterfaceAudience.Private +public class AssignRegionHandler extends EventHandler { + + private static final Logger LOG = LoggerFactory.getLogger(AssignRegionHandler.class); + + private final RegionInfo regionInfo; + + private final TableDescriptor tableDesc; + + private final long masterSystemTime; + + private final RetryCounter retryCounter; + + public AssignRegionHandler(RegionServerServices server, RegionInfo regionInfo, + @Nullable TableDescriptor tableDesc, long masterSystemTime, EventType eventType) { + super(server, eventType); + this.regionInfo = regionInfo; + this.tableDesc = tableDesc; + this.masterSystemTime = masterSystemTime; + this.retryCounter = HandlerUtil.getRetryCounter(); + } + + private RegionServerServices getServer() { + return (RegionServerServices) server; + } + + private void cleanUpAndReportFailure(IOException error) throws IOException { + LOG.warn("Failed to open region {}, will report to master", regionInfo.getRegionNameAsString(), + error); + RegionServerServices rs = getServer(); + rs.getRegionsInTransitionInRS().remove(regionInfo.getEncodedNameAsBytes(), Boolean.TRUE); + if (!rs.reportRegionStateTransition(new RegionStateTransitionContext(TransitionCode.FAILED_OPEN, + HConstants.NO_SEQNUM, masterSystemTime, regionInfo))) { + throw new IOException( + "Failed to report failed open to master: " + regionInfo.getRegionNameAsString()); + } + } + + @Override + public void process() throws IOException { + RegionServerServices rs = getServer(); + String encodedName = regionInfo.getEncodedName(); + byte[] encodedNameBytes = regionInfo.getEncodedNameAsBytes(); + String regionName = regionInfo.getRegionNameAsString(); + Region onlineRegion = rs.getRegion(encodedName); + if (onlineRegion != null) { + LOG.warn("Received OPEN for the region:{}, which is already online", regionName); + // Just follow the old behavior, do we need to call reportRegionStateTransition? Maybe not? + // For normal case, it could happen that the rpc call to schedule this handler is succeeded, + // but before returning to master the connection is broken. And when master tries again, we + // have already finished the opening. For this case we do not need to call + // reportRegionStateTransition any more. + return; + } + LOG.info("Open {}", regionName); + Boolean previous = rs.getRegionsInTransitionInRS().putIfAbsent(encodedNameBytes, Boolean.TRUE); + if (previous != null) { + if (previous) { + // The region is opening and this maybe a retry on the rpc call, it is safe to ignore it. + LOG.info("Receiving OPEN for the region:{}, which we are already trying to OPEN" + + " - ignoring this new request for this region.", regionName); + } else { + // The region is closing. This is possible as we will update the region state to CLOSED when + // calling reportRegionStateTransition, so the HMaster will think the region is offline, + // before we actually close the region, as reportRegionStateTransition is part of the + // closing process. + long backoff = retryCounter.getBackoffTimeAndIncrementAttempts(); + LOG.info( + "Receiving OPEN for the region:{}, which we are trying to close, try again after {}ms", + regionName, backoff); + rs.getExecutorService().delayedSubmit(this, backoff, TimeUnit.MILLISECONDS); + } + return; + } + HRegion region; + try { + TableDescriptor htd = + tableDesc != null ? tableDesc : rs.getTableDescriptors().get(regionInfo.getTable()); + if (htd == null) { + throw new IOException("Missing table descriptor for " + regionName); + } + // pass null for the last parameter, which used to be a CancelableProgressable, as now the + // opening can not be interrupted by a close request any more. + region = HRegion.openHRegion(regionInfo, htd, rs.getWAL(regionInfo), rs.getConfiguration(), + rs, null); + } catch (IOException e) { + cleanUpAndReportFailure(e); + return; + } + rs.postOpenDeployTasks(new PostOpenDeployContext(region, masterSystemTime)); + rs.addRegion(region); + LOG.info("Opened {}", regionName); + Boolean current = rs.getRegionsInTransitionInRS().remove(regionInfo.getEncodedNameAsBytes()); + if (current == null) { + // Should NEVER happen, but let's be paranoid. + LOG.error("Bad state: we've just opened a region that was NOT in transition. Region={}", + regionName); + } else if (!current) { + // Should NEVER happen, but let's be paranoid. + LOG.error("Bad state: we've just opened a region that was closing. Region={}", regionName); + } + } + + @Override + protected void handleException(Throwable t) { + LOG.warn("Fatal error occured while opening region {}, aborting...", + regionInfo.getRegionNameAsString(), t); + getServer().abort( + "Failed to open region " + regionInfo.getRegionNameAsString() + " and can not recover", t); + } + + public static AssignRegionHandler create(RegionServerServices server, RegionInfo regionInfo, + TableDescriptor tableDesc, long masterSystemTime) { + EventType eventType; + if (regionInfo.isMetaRegion()) { + eventType = EventType.M_RS_CLOSE_META; + } else if (regionInfo.getTable().isSystemTable() || + (tableDesc != null && tableDesc.getPriority() >= HConstants.ADMIN_QOS)) { + eventType = EventType.M_RS_OPEN_PRIORITY_REGION; + } else { + eventType = EventType.M_RS_OPEN_REGION; + } + return new AssignRegionHandler(server, regionInfo, tableDesc, masterSystemTime, eventType); + } +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/CloseRegionHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/CloseRegionHandler.java index f851dfacbea5..0e35a0be70d1 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/CloseRegionHandler.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/CloseRegionHandler.java @@ -36,6 +36,11 @@ /** * Handles closing of a region on a region server. + *

    + * Now for regular close region request, we will use {@link UnassignRegionHandler} instead. But when + * shutting down the region server, will also close regions and the related methods still use this + * class so we keep it here. + * @see UnassignRegionHandler */ @InterfaceAudience.Private public class CloseRegionHandler extends EventHandler { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/HandlerUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/HandlerUtil.java new file mode 100644 index 000000000000..02ed0ef71c59 --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/HandlerUtil.java @@ -0,0 +1,41 @@ +/** + * 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.regionserver.handler; + +import java.util.concurrent.TimeUnit; +import org.apache.hadoop.hbase.util.RetryCounter; +import org.apache.hadoop.hbase.util.RetryCounterFactory; +import org.apache.yetus.audience.InterfaceAudience; + +@InterfaceAudience.Private +final class HandlerUtil { + + private HandlerUtil() { + } + + /** + * Get an exponential backoff retry counter. The base unit is 100 milliseconds, and the max + * backoff time is 30 seconds. + */ + public static RetryCounter getRetryCounter() { + return new RetryCounterFactory( + new RetryCounter.RetryConfig().setBackoffPolicy(new RetryCounter.ExponentialBackoffPolicy()) + .setSleepInterval(100).setMaxSleepTime(30000).setMaxAttempts(Integer.MAX_VALUE) + .setTimeUnit(TimeUnit.MILLISECONDS).setJitter(0.01f)).create(); + } +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/OpenRegionHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/OpenRegionHandler.java index 970911fde702..31177ef79cb4 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/OpenRegionHandler.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/OpenRegionHandler.java @@ -41,7 +41,10 @@ * Handles opening of a region on a region server. *

    * This is executed after receiving an OPEN RPC from the master or client. + * @deprecated Keep it here only for compatible + * @see AssignRegionHandler */ +@Deprecated @InterfaceAudience.Private public class OpenRegionHandler extends EventHandler { private static final Logger LOG = LoggerFactory.getLogger(OpenRegionHandler.class); @@ -172,7 +175,7 @@ private void doCleanUpOnFailedOpen(HRegion region) * state meantime so master doesn't timeout our region-in-transition. * Caller must cleanup region if this fails. */ - boolean updateMeta(final HRegion r, long masterSystemTime) { + private boolean updateMeta(final HRegion r, long masterSystemTime) { if (this.server.isStopped() || this.rsServices.isStopping()) { return false; } @@ -275,7 +278,7 @@ Throwable getException() { /** * @return Instance of HRegion if successful open else null. */ - HRegion openRegion() { + private HRegion openRegion() { HRegion region = null; try { // Instantiate the region. This also periodically tickles OPENING @@ -304,7 +307,7 @@ public boolean progress() { return region; } - void cleanupFailedOpen(final HRegion region) throws IOException { + private void cleanupFailedOpen(final HRegion region) throws IOException { if (region != null) { this.rsServices.removeRegion(region, null); region.close(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/UnassignRegionHandler.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/UnassignRegionHandler.java new file mode 100644 index 000000000000..cd38db14c7d6 --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/handler/UnassignRegionHandler.java @@ -0,0 +1,143 @@ +/** + * 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.regionserver.handler; + +import edu.umd.cs.findbugs.annotations.Nullable; +import java.io.IOException; +import java.util.concurrent.TimeUnit; +import org.apache.hadoop.hbase.HConstants; +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.regionserver.HRegion; +import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.RegionServerServices; +import org.apache.hadoop.hbase.regionserver.RegionServerServices.RegionStateTransitionContext; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.RetryCounter; +import org.apache.yetus.audience.InterfaceAudience; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode; + +/** + * Handles closing of a region on a region server. + *

    + * Just done the same thing with the old {@link CloseRegionHandler}, with some modifications on + * fencing and retrying. But we need to keep the {@link CloseRegionHandler} as is to keep compatible + * with the zk less assignment for 1.x, otherwise it is not possible to do rolling upgrade. + */ +@InterfaceAudience.Private +public class UnassignRegionHandler extends EventHandler { + + private static final Logger LOG = LoggerFactory.getLogger(UnassignRegionHandler.class); + + private final String encodedName; + // If true, the hosting server is aborting. Region close process is different + // when we are aborting. + private final boolean abort; + + private final ServerName destination; + + private final RetryCounter retryCounter; + + public UnassignRegionHandler(RegionServerServices server, String encodedName, boolean abort, + @Nullable ServerName destination, EventType eventType) { + super(server, eventType); + this.encodedName = encodedName; + this.abort = abort; + this.destination = destination; + this.retryCounter = HandlerUtil.getRetryCounter(); + } + + private RegionServerServices getServer() { + return (RegionServerServices) server; + } + + @Override + public void process() throws IOException { + RegionServerServices rs = getServer(); + byte[] encodedNameBytes = Bytes.toBytes(encodedName); + Boolean previous = rs.getRegionsInTransitionInRS().putIfAbsent(encodedNameBytes, Boolean.FALSE); + if (previous != null) { + if (previous) { + // This could happen as we will update the region state to OPEN when calling + // reportRegionStateTransition, so the HMaster will think the region is online, before we + // actually open the region, as reportRegionStateTransition is part of the opening process. + long backoff = retryCounter.getBackoffTimeAndIncrementAttempts(); + LOG.warn("Received CLOSE for the region: {}, which we are already " + + "trying to OPEN. try again after {}ms", encodedName, backoff); + rs.getExecutorService().delayedSubmit(this, backoff, TimeUnit.MILLISECONDS); + } else { + LOG.info("Received CLOSE for the region: {}, which we are already trying to CLOSE," + + " but not completed yet", encodedName); + } + return; + } + HRegion region = (HRegion) rs.getRegion(encodedName); + if (region == null) { + LOG.debug( + "Received CLOSE for a region {} which is not online, and we're not opening/closing.", + encodedName); + rs.getRegionsInTransitionInRS().remove(encodedNameBytes, Boolean.FALSE); + return; + } + String regionName = region.getRegionInfo().getEncodedName(); + LOG.info("Close {}", regionName); + if (region.getCoprocessorHost() != null) { + // XXX: The behavior is a bit broken. At master side there is no FAILED_CLOSE state, so if + // there are exception thrown from the CP, we can not report the error to master, and if here + // we just return without calling reportRegionStateTransition, the TRSP at master side will + // hang there for ever. So here if the CP throws an exception out, the only way is to abort + // the RS... + region.getCoprocessorHost().preClose(abort); + } + if (region.close(abort) == null) { + // XXX: Is this still possible? The old comment says about split, but now split is done at + // master side, so... + LOG.warn("Can't close region {}, was already closed during close()", regionName); + rs.getRegionsInTransitionInRS().remove(encodedNameBytes, Boolean.FALSE); + return; + } + rs.removeRegion(region, destination); + if (!rs.reportRegionStateTransition(new RegionStateTransitionContext(TransitionCode.CLOSED, + HConstants.NO_SEQNUM, -1, region.getRegionInfo()))) { + throw new IOException("Failed to report close to master: " + regionName); + } + rs.getRegionsInTransitionInRS().remove(encodedNameBytes, Boolean.FALSE); + LOG.info("Closed {}", regionName); + } + + @Override + protected void handleException(Throwable t) { + LOG.warn("Fatal error occured while closing region {}, aborting...", encodedName, t); + getServer().abort("Failed to close region " + encodedName + " and can not recover", t); + } + + public static UnassignRegionHandler create(RegionServerServices server, String encodedName, + boolean abort, @Nullable ServerName destination) { + // Just try our best to determine whether it is for closing meta. It is not the end of the world + // if we put the handler into a wrong executor. + Region region = server.getRegion(encodedName); + EventType eventType = + region != null && region.getRegionInfo().isMetaRegion() ? EventType.M_RS_CLOSE_META + : EventType.M_RS_CLOSE_REGION; + return new UnassignRegionHandler(server, encodedName, abort, destination, eventType); + } +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/AbstractFSWAL.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/AbstractFSWAL.java index 2b45a04341fb..7915ac3cef83 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/AbstractFSWAL.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/AbstractFSWAL.java @@ -34,8 +34,6 @@ import java.util.Map; import java.util.OptionalLong; import java.util.Set; -import java.util.concurrent.ConcurrentHashMap; -import java.util.concurrent.ConcurrentMap; import java.util.concurrent.ConcurrentNavigableMap; import java.util.concurrent.ConcurrentSkipListMap; import java.util.concurrent.CopyOnWriteArrayList; @@ -62,7 +60,6 @@ import org.apache.hadoop.hbase.regionserver.MultiVersionConcurrencyControl; import org.apache.hadoop.hbase.trace.TraceUtil; import org.apache.hadoop.hbase.util.Bytes; -import org.apache.hadoop.hbase.util.CollectionUtils; import org.apache.hadoop.hbase.util.CommonFSUtils; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; import org.apache.hadoop.hbase.util.FSUtils; @@ -268,14 +265,11 @@ public WalProps(Map encodedName2HighestSequenceId, long logSize) { new ConcurrentSkipListMap<>(LOG_NAME_COMPARATOR); /** - * Map of {@link SyncFuture}s keyed by Handler objects. Used so we reuse SyncFutures. + * Map of {@link SyncFuture}s owned by Thread objects. Used so we reuse SyncFutures. + * Thread local is used so JVM can GC the terminated thread for us. See HBASE-21228 *

    - * TODO: Reuse FSWALEntry's rather than create them anew each time as we do SyncFutures here. - *

    - * TODO: Add a FSWalEntry and SyncFuture as thread locals on handlers rather than have them get - * them from this Map? */ - private final ConcurrentMap syncFuturesByHandler; + private final ThreadLocal cachedSyncFutures; /** * The class name of the runtime implementation, used as prefix for logging/tracing. @@ -414,11 +408,6 @@ public boolean accept(final Path fileName) { this.blocksize = WALUtil.getWALBlockSize(this.conf, this.fs, this.walDir); float multiplier = conf.getFloat("hbase.regionserver.logroll.multiplier", 0.5f); this.logrollsize = (long)(this.blocksize * multiplier); - - boolean maxLogsDefined = conf.get("hbase.regionserver.maxlogs") != null; - if (maxLogsDefined) { - LOG.warn("'hbase.regionserver.maxlogs' was deprecated."); - } this.maxLogs = conf.getInt("hbase.regionserver.maxlogs", Math.max(32, calculateMaxLogFiles(conf, logrollsize))); @@ -429,9 +418,12 @@ public boolean accept(final Path fileName) { .toNanos(conf.getInt("hbase.regionserver.hlog.slowsync.ms", DEFAULT_SLOW_SYNC_TIME_MS)); this.walSyncTimeoutNs = TimeUnit.MILLISECONDS .toNanos(conf.getLong("hbase.regionserver.hlog.sync.timeout", DEFAULT_WAL_SYNC_TIMEOUT_MS)); - int maxHandlersCount = conf.getInt(HConstants.REGION_SERVER_HANDLER_COUNT, 200); - // Presize our map of SyncFutures by handler objects. - this.syncFuturesByHandler = new ConcurrentHashMap<>(maxHandlersCount); + this.cachedSyncFutures = new ThreadLocal() { + @Override + protected SyncFuture initialValue() { + return new SyncFuture(); + } + }; this.implClassName = getClass().getSimpleName(); } @@ -730,7 +722,7 @@ protected final void blockOnSync(SyncFuture syncFuture) throws IOException { // SyncFuture reuse by thread, if TimeoutIOException happens, ringbuffer // still refer to it, so if this thread use it next time may get a wrong // result. - this.syncFuturesByHandler.remove(Thread.currentThread()); + this.cachedSyncFutures.remove(); throw tioe; } catch (InterruptedException ie) { LOG.warn("Interrupted", ie); @@ -879,9 +871,7 @@ public void updateStore(byte[] encodedRegionName, byte[] familyName, Long sequen } protected final SyncFuture getSyncFuture(long sequence) { - return CollectionUtils - .computeIfAbsent(syncFuturesByHandler, Thread.currentThread(), SyncFuture::new) - .reset(sequence); + return cachedSyncFutures.get().reset(sequence); } protected final void requestLogRoll(boolean tooFewReplicas) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsSource.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsSource.java index 906f0c6d3307..830ebe182d29 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsSource.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/MetricsSource.java @@ -326,6 +326,10 @@ public void incrCompletedRecoveryQueue() { globalSourceSource.incrCompletedRecoveryQueue(); } + public void incrFailedRecoveryQueue() { + globalSourceSource.incrFailedRecoveryQueue(); + } + @Override public void init() { singleSourceSource.init(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/ReplicationSourceManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/ReplicationSourceManager.java index 428ec98df939..5756cbc9d0fa 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/ReplicationSourceManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/replication/regionserver/ReplicationSourceManager.java @@ -45,6 +45,7 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.CompatibilitySingletonFactory; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.Server; import org.apache.hadoop.hbase.ServerName; @@ -820,6 +821,8 @@ private void transferQueues(ServerName deadRS) { try { this.executor.execute(transfer); } catch (RejectedExecutionException ex) { + CompatibilitySingletonFactory.getInstance(MetricsReplicationSourceFactory.class) + .getGlobalSource().incrFailedRecoveryQueue(); LOG.info("Cancelling the transfer of " + deadRS + " because of " + ex.getMessage()); } } @@ -891,7 +894,12 @@ public void run() { queueStorage.removeReplicatorIfQueueIsEmpty(deadRS); } } catch (ReplicationException e) { - server.abort("Failed to claim queue from dead regionserver", e); + LOG.error(String.format("ReplicationException: cannot claim dead region (%s)'s " + + "replication queue. Znode : (%s)" + + " Possible solution: check if znode size exceeds jute.maxBuffer value. " + + " If so, increase it for both client and server side." + e), deadRS, + queueStorage.getRsNode(deadRS)); + server.abort("Failed to claim queue from dead regionserver.", e); return; } // Copying over the failed queue is completed. diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/HBasePolicyProvider.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/HBasePolicyProvider.java index 76d185fa0169..72e36a8fe474 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/security/HBasePolicyProvider.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/security/HBasePolicyProvider.java @@ -17,7 +17,7 @@ */ package org.apache.hadoop.hbase.security; -import org.apache.yetus.audience.InterfaceAudience; +import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProtos; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.AdminService; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.ClientService; @@ -27,6 +27,7 @@ import org.apache.hadoop.security.authorize.ProxyUsers; import org.apache.hadoop.security.authorize.Service; import org.apache.hadoop.security.authorize.ServiceAuthorizationManager; +import org.apache.yetus.audience.InterfaceAudience; /** * Implementation of secure Hadoop policy provider for mapping @@ -35,10 +36,13 @@ @InterfaceAudience.Private public class HBasePolicyProvider extends PolicyProvider { protected final static Service[] services = { - new Service("security.client.protocol.acl", ClientService.BlockingInterface.class), - new Service("security.client.protocol.acl", AdminService.BlockingInterface.class), - new Service("security.admin.protocol.acl", MasterService.BlockingInterface.class), - new Service("security.masterregion.protocol.acl", RegionServerStatusService.BlockingInterface.class) + new Service("security.client.protocol.acl", ClientService.BlockingInterface.class), + new Service("security.client.protocol.acl", AdminService.BlockingInterface.class), + new Service("security.client.protocol.acl", + MasterProtos.HbckService.BlockingInterface.class), + new Service("security.admin.protocol.acl", MasterService.BlockingInterface.class), + new Service("security.masterregion.protocol.acl", + RegionServerStatusService.BlockingInterface.class) }; @Override diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java index 7a549fce22c0..40f4aa6654f4 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/tool/Canary.java @@ -90,6 +90,7 @@ import org.apache.hadoop.util.GenericOptionsParser; import org.apache.hadoop.util.Tool; import org.apache.hadoop.util.ToolRunner; +import org.apache.hbase.thirdparty.com.google.common.annotations.VisibleForTesting; import org.apache.yetus.audience.InterfaceAudience; import org.apache.zookeeper.KeeperException; import org.apache.zookeeper.ZooKeeper; @@ -101,39 +102,45 @@ import org.apache.hbase.thirdparty.com.google.common.collect.Lists; /** - * HBase Canary Tool, that that can be used to do - * "canary monitoring" of a running HBase cluster. + * HBase Canary Tool for "canary monitoring" of a running HBase cluster. * - * Here are three modes - * 1. region mode - Foreach region tries to get one row per column family - * and outputs some information about failure or latency. + * There are three modes: + *

      + *
    1. region mode (Default): For each region, try to get one row per column family outputting + * information on failure (ERROR) or else the latency. + *
      2. * - * 2. regionserver mode - Foreach regionserver tries to get one row from one table - * selected randomly and outputs some information about failure or latency. + *
    2. regionserver mode: For each regionserver try to get one row from one table selected + * randomly outputting information on failure (ERROR) or else the latency. + *
      3. * - * 3. zookeeper mode - for each zookeeper instance, selects a zNode and - * outputs some information about failure or latency. + *
    3. zookeeper mode: for each zookeeper instance, selects a znode outputting information on + * failure (ERROR) or else the latency. + *
      4. + *
    */ @InterfaceAudience.Private public final class Canary implements Tool { - // Sink interface used by the canary to outputs information + /** + * Sink interface used by the canary to output information + */ public interface Sink { - public long getReadFailureCount(); - public long incReadFailureCount(); - public Map getReadFailures(); - public void updateReadFailures(String regionName, String serverName); - public long getWriteFailureCount(); - public long incWriteFailureCount(); - public Map getWriteFailures(); - public void updateWriteFailures(String regionName, String serverName); + long getReadFailureCount(); + long incReadFailureCount(); + Map getReadFailures(); + void updateReadFailures(String regionName, String serverName); + long getWriteFailureCount(); + long incWriteFailureCount(); + Map getWriteFailures(); + void updateWriteFailures(String regionName, String serverName); } - // Simple implementation of canary sink that allows to plot on - // file or standard output timings or failures. + /** + * Simple implementation of canary sink that allows plotting to a file or standard output. + */ public static class StdOutSink implements Sink { private AtomicLong readFailureCount = new AtomicLong(0), writeFailureCount = new AtomicLong(0); - private Map readFailures = new ConcurrentHashMap<>(); private Map writeFailures = new ConcurrentHashMap<>(); @@ -178,67 +185,75 @@ public void updateWriteFailures(String regionName, String serverName) { } } + /** + * By RegionServer, for 'regionserver' mode. + */ public static class RegionServerStdOutSink extends StdOutSink { - public void publishReadFailure(String table, String server) { incReadFailureCount(); - LOG.error(String.format("Read from table:%s on region server:%s", table, server)); + LOG.error("Read from {} on {}", table, server); } public void publishReadTiming(String table, String server, long msTime) { - LOG.info(String.format("Read from table:%s on region server:%s in %dms", - table, server, msTime)); + LOG.info("Read from {} on {} in {}ms", table, server, msTime); } } + /** + * Output for 'zookeeper' mode. + */ public static class ZookeeperStdOutSink extends StdOutSink { - - public void publishReadFailure(String zNode, String server) { + public void publishReadFailure(String znode, String server) { incReadFailureCount(); - LOG.error(String.format("Read from zNode:%s on zookeeper instance:%s", zNode, server)); + LOG.error("Read from {} on {}", znode, server); } public void publishReadTiming(String znode, String server, long msTime) { - LOG.info(String.format("Read from zNode:%s on zookeeper instance:%s in %dms", - znode, server, msTime)); + LOG.info("Read from {} on {} in {}ms", znode, server, msTime); } } + /** + * By Region, for 'region' mode. + */ public static class RegionStdOutSink extends StdOutSink { - private Map perTableReadLatency = new HashMap<>(); private LongAdder writeLatency = new LongAdder(); public void publishReadFailure(ServerName serverName, RegionInfo region, Exception e) { incReadFailureCount(); - LOG.error(String.format("read from region %s on regionserver %s failed", region.getRegionNameAsString(), serverName), e); + LOG.error("Read from {} on {} failed", region.getRegionNameAsString(), serverName, e); } - public void publishReadFailure(ServerName serverName, RegionInfo region, ColumnFamilyDescriptor column, Exception e) { + public void publishReadFailure(ServerName serverName, RegionInfo region, + ColumnFamilyDescriptor column, Exception e) { incReadFailureCount(); - LOG.error(String.format("read from region %s on regionserver %s column family %s failed", - region.getRegionNameAsString(), serverName, column.getNameAsString()), e); + LOG.error("Read from {} on {} {} failed", region.getRegionNameAsString(), serverName, + column.getNameAsString(), e); } - public void publishReadTiming(ServerName serverName, RegionInfo region, ColumnFamilyDescriptor column, long msTime) { - LOG.info(String.format("read from region %s on regionserver %s column family %s in %dms", - region.getRegionNameAsString(), serverName, column.getNameAsString(), msTime)); + public void publishReadTiming(ServerName serverName, RegionInfo region, + ColumnFamilyDescriptor column, long msTime) { + LOG.info("Read from {} on {} {} in {}ms", region.getRegionNameAsString(), serverName, + column.getNameAsString(), msTime); } public void publishWriteFailure(ServerName serverName, RegionInfo region, Exception e) { incWriteFailureCount(); - LOG.error(String.format("write to region %s on regionserver %s failed", region.getRegionNameAsString(), serverName), e); + LOG.error("Write to {} on {} failed", region.getRegionNameAsString(), serverName, e); } - public void publishWriteFailure(ServerName serverName, RegionInfo region, ColumnFamilyDescriptor column, Exception e) { + public void publishWriteFailure(ServerName serverName, RegionInfo region, + ColumnFamilyDescriptor column, Exception e) { incWriteFailureCount(); - LOG.error(String.format("write to region %s on regionserver %s column family %s failed", - region.getRegionNameAsString(), serverName, column.getNameAsString()), e); + LOG.error("Write to {} on {} {} failed", region.getRegionNameAsString(), serverName, + column.getNameAsString(), e); } - public void publishWriteTiming(ServerName serverName, RegionInfo region, ColumnFamilyDescriptor column, long msTime) { - LOG.info(String.format("write to region %s on regionserver %s column family %s in %dms", - region.getRegionNameAsString(), serverName, column.getNameAsString(), msTime)); + public void publishWriteTiming(ServerName serverName, RegionInfo region, + ColumnFamilyDescriptor column, long msTime) { + LOG.info("Write to {} on {} {} in {}ms", + region.getRegionNameAsString(), serverName, column.getNameAsString(), msTime); } public Map getReadLatencyMap() { @@ -260,6 +275,9 @@ public LongAdder getWriteLatency() { } } + /** + * Run a single zookeeper Task and then exit. + */ static class ZookeeperTask implements Callable { private final Connection connection; private final String host; @@ -298,8 +316,8 @@ public ZookeeperTask(Connection connection, String host, String znode, int timeo } /** - * For each column family of the region tries to get one row and outputs the latency, or the - * failure. + * Run a single Region Task and then exit. For each column family of the Region, get one row and + * output latency or failure. */ static class RegionTask implements Callable { public enum TaskType{ @@ -313,8 +331,8 @@ public enum TaskType{ private ServerName serverName; private LongAdder readWriteLatency; - RegionTask(Connection connection, RegionInfo region, ServerName serverName, RegionStdOutSink sink, - TaskType taskType, boolean rawScanEnabled, LongAdder rwLatency) { + RegionTask(Connection connection, RegionInfo region, ServerName serverName, + RegionStdOutSink sink, TaskType taskType, boolean rawScanEnabled, LongAdder rwLatency) { this.connection = connection; this.region = region; this.serverName = serverName; @@ -340,14 +358,11 @@ public Void read() { Table table = null; TableDescriptor tableDesc = null; try { - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading table descriptor for table %s", - region.getTable())); - } + LOG.debug("Reading table descriptor for table {}", region.getTable()); table = connection.getTable(region.getTable()); tableDesc = table.getDescriptor(); } catch (IOException e) { - LOG.debug("sniffRegion failed", e); + LOG.debug("sniffRegion {} of {} failed", region.getEncodedName(), e); sink.publishReadFailure(serverName, region, e); if (table != null) { try { @@ -375,10 +390,7 @@ public Void read() { get.addFamily(column.getName()); } else { scan = new Scan(); - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("rawScan : %s for table: %s", rawScanEnabled, - tableDesc.getTableName())); - } + LOG.debug("rawScan {} for {}", rawScanEnabled, tableDesc.getTableName()); scan.setRaw(rawScanEnabled); scan.setCaching(1); scan.setCacheBlocks(false); @@ -387,12 +399,9 @@ public Void read() { scan.setMaxResultSize(1L); scan.setOneRowLimit(); } - - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading from table %s region %s column family %s and key %s", - tableDesc.getTableName(), region.getRegionNameAsString(), column.getNameAsString(), - Bytes.toStringBinary(startKey))); - } + LOG.debug("Reading from {} {} {} {}", tableDesc.getTableName(), + region.getRegionNameAsString(), column.getNameAsString(), + Bytes.toStringBinary(startKey)); try { stopWatch.start(); if (startKey.length > 0) { @@ -425,7 +434,6 @@ public Void read() { /** * Check writes for the canary table - * @return */ private Void write() { Table table = null; @@ -445,11 +453,9 @@ private Void write() { Bytes.random(value); put.addColumn(column.getName(), HConstants.EMPTY_BYTE_ARRAY, value); - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("writing to table %s region %s column family %s and key %s", - tableDesc.getTableName(), region.getRegionNameAsString(), column.getNameAsString(), - Bytes.toStringBinary(rowToCheck))); - } + LOG.debug("Writing to {} {} {} {}", + tableDesc.getTableName(), region.getRegionNameAsString(), column.getNameAsString(), + Bytes.toStringBinary(rowToCheck)); try { long startTime = System.currentTimeMillis(); table.put(put); @@ -470,7 +476,8 @@ private Void write() { } /** - * Get one row from a region on the regionserver and outputs the latency, or the failure. + * Run a single RegionServer Task and then exit. + * Get one row from a region on the regionserver and output latency or the failure. */ static class RegionServerTask implements Callable { private Connection connection; @@ -503,11 +510,9 @@ public Void call() { table = connection.getTable(tableName); startKey = region.getStartKey(); // Can't do a get on empty start row so do a Scan of first element if any instead. - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading from region server %s table %s region %s and key %s", - serverName, region.getTable(), region.getRegionNameAsString(), - Bytes.toStringBinary(startKey))); - } + LOG.debug("Reading from {} {} {} {}", + serverName, region.getTable(), region.getRegionNameAsString(), + Bytes.toStringBinary(startKey)); if (startKey.length > 0) { get = new Get(startKey); get.setCacheBlocks(false); @@ -584,23 +589,43 @@ public Void call() { private boolean useRegExp; private long timeout = DEFAULT_TIMEOUT; private boolean failOnError = true; + + /** + * True if we are to run in 'regionServer' mode. + */ private boolean regionServerMode = false; + + /** + * True if we are to run in zookeeper 'mode'. + */ private boolean zookeeperMode = false; + private long permittedFailures = 0; private boolean regionServerAllRegions = false; private boolean writeSniffing = false; private long configuredWriteTableTimeout = DEFAULT_TIMEOUT; private boolean treatFailureAsError = false; private TableName writeTableName = DEFAULT_WRITE_TABLE_NAME; + + /** + * This is a Map of table to timeout. The timeout is for reading all regions in the table; i.e. + * we aggregate time to fetch each region and it needs to be less than this value else we + * log an ERROR. + */ private HashMap configuredReadTableTimeouts = new HashMap<>(); private ExecutorService executor; // threads to retrieve data from regionservers public Canary() { - this(new ScheduledThreadPoolExecutor(1), new RegionServerStdOutSink()); + this(new ScheduledThreadPoolExecutor(1)); + } + + public Canary(ExecutorService executor) { + this(executor, null); } - public Canary(ExecutorService executor, Sink sink) { + @VisibleForTesting + Canary(ExecutorService executor, Sink sink) { this.executor = executor; this.sink = sink; } @@ -628,7 +653,7 @@ private int parseArgs(String[] args) { printUsageAndExit(); } - if (cmd.equals("-help")) { + if (cmd.equals("-help") || cmd.equals("-h")) { // user asked for help, print the help and quit. printUsageAndExit(); } else if (cmd.equals("-daemon") && interval == 0) { @@ -639,7 +664,7 @@ private int parseArgs(String[] args) { i++; if (i == args.length) { - System.err.println("-interval needs a numeric value argument."); + System.err.println("-interval takes a numeric seconds value argument."); printUsageAndExit(); } @@ -657,7 +682,7 @@ private int parseArgs(String[] args) { this.regionServerAllRegions = true; } else if(cmd.equals("-writeSniffing")) { this.writeSniffing = true; - } else if(cmd.equals("-treatFailureAsError")) { + } else if(cmd.equals("-treatFailureAsError") || cmd.equals("-failureAsError")) { this.treatFailureAsError = true; } else if (cmd.equals("-e")) { this.useRegExp = true; @@ -665,35 +690,35 @@ private int parseArgs(String[] args) { i++; if (i == args.length) { - System.err.println("-t needs a numeric value argument."); + System.err.println("-t takes a numeric milliseconds value argument."); printUsageAndExit(); } try { this.timeout = Long.parseLong(args[i]); } catch (NumberFormatException e) { - System.err.println("-t needs a numeric value argument."); + System.err.println("-t takes a numeric milliseconds value argument."); printUsageAndExit(); } } else if(cmd.equals("-writeTableTimeout")) { i++; if (i == args.length) { - System.err.println("-writeTableTimeout needs a numeric value argument."); + System.err.println("-writeTableTimeout takes a numeric milliseconds value argument."); printUsageAndExit(); } try { this.configuredWriteTableTimeout = Long.parseLong(args[i]); } catch (NumberFormatException e) { - System.err.println("-writeTableTimeout needs a numeric value argument."); + System.err.println("-writeTableTimeout takes a numeric milliseconds value argument."); printUsageAndExit(); } } else if (cmd.equals("-writeTable")) { i++; if (i == args.length) { - System.err.println("-writeTable needs a string value argument."); + System.err.println("-writeTable takes a string tablename value argument."); printUsageAndExit(); } this.writeTableName = TableName.valueOf(args[i]); @@ -711,14 +736,16 @@ private int parseArgs(String[] args) { i++; if (i == args.length) { - System.err.println("-readTableTimeouts needs a comma-separated list of read timeouts per table (without spaces)."); + System.err.println("-readTableTimeouts needs a comma-separated list of read " + + "millisecond timeouts per table (without spaces)."); printUsageAndExit(); } String [] tableTimeouts = args[i].split(","); for (String tT: tableTimeouts) { String [] nameTimeout = tT.split("="); if (nameTimeout.length < 2) { - System.err.println("Each -readTableTimeouts argument must be of the form =."); + System.err.println("Each -readTableTimeouts argument must be of the form " + + "= (without spaces)."); printUsageAndExit(); } long timeoutVal = 0L; @@ -856,41 +883,56 @@ public Map getWriteFailures() { private void printUsageAndExit() { System.err.println( - "Usage: hbase canary [opts] [table1 [table2]...] | [regionserver1 [regionserver2]..]"); - System.err.println(" where [opts] are:"); - System.err.println(" -help Show this help and exit."); - System.err.println(" -regionserver replace the table argument to regionserver,"); - System.err.println(" which means to enable regionserver mode"); - System.err.println(" -allRegions Tries all regions on a regionserver,"); - System.err.println(" only works in regionserver mode."); - System.err.println(" -zookeeper Tries to grab zookeeper.znode.parent "); - System.err.println(" on each zookeeper instance"); - System.err.println(" -permittedZookeeperFailures Ignore first N failures when attempting to "); - System.err.println(" connect to individual zookeeper nodes in the ensemble"); - System.err.println(" -daemon Continuous check at defined intervals."); - System.err.println(" -interval Interval between checks (sec)"); - System.err.println(" -e Use table/regionserver as regular expression"); - System.err.println(" which means the table/regionserver is regular expression pattern"); - System.err.println(" -f stop whole program if first error occurs," + - " default is true"); - System.err.println(" -t timeout for a check, default is 600000 (millisecs)"); - System.err.println(" -writeTableTimeout write timeout for the writeTable, default is 600000 (millisecs)"); - System.err.println(" -readTableTimeouts =,=, ... " - + "comma-separated list of read timeouts per table (no spaces), default is 600000 (millisecs)"); - System.err.println(" -writeSniffing enable the write sniffing in canary"); - System.err.println(" -treatFailureAsError treats read / write failure as error"); - System.err.println(" -writeTable The table used for write sniffing." - + " Default is hbase:canary"); - System.err.println(" -Dhbase.canary.read.raw.enabled= Use this flag to enable or disable raw scan during read canary test" - + " Default is false and raw is not enabled during scan"); - System.err - .println(" -D= assigning or override the configuration params"); + "Usage: canary [OPTIONS] [ [ [ interval between checks in seconds"); + System.err.println(" -e consider table/regionserver argument as regular " + + "expression"); + System.err.println(" -f exit on first error; default=true"); + System.err.println(" -failureAsError treat read/write failure as error"); + System.err.println(" -t timeout for canary-test run; default=600000ms"); + System.err.println(" -writeSniffing enable write sniffing"); + System.err.println(" -writeTable the table used for write sniffing; default=hbase:canary"); + System.err.println(" -writeTableTimeout timeout for writeTable; default=600000ms"); + System.err.println(" -readTableTimeouts =," + + "=,..."); + System.err.println(" comma-separated list of table read timeouts " + + "(no spaces);"); + System.err.println(" logs 'ERROR' if takes longer. default=600000ms"); + System.err.println(" -permittedZookeeperFailures Ignore first N failures attempting to "); + System.err.println(" connect to individual zookeeper nodes in ensemble"); + System.err.println(""); + System.err.println(" -D= to assign or override configuration params"); + System.err.println(" -Dhbase.canary.read.raw.enabled= Set to enable/disable " + + "raw scan; default=false"); + System.err.println(""); + System.err.println("Canary runs in one of three modes: region (default), regionserver, or " + + "zookeeper."); + System.err.println("To sniff/probe all regions, pass no arguments."); + System.err.println("To sniff/probe all regions of a table, pass tablename."); + System.err.println("To sniff/probe regionservers, pass -regionserver, etc."); + System.err.println("See http://hbase.apache.org/book.html#_canary for Canary documentation."); System.exit(USAGE_EXIT_CODE); } + Sink getSink(Configuration configuration, Class clazz) { + // In test context, this.sink might be set. Use it if non-null. For testing. + return this.sink != null? this.sink: + (Sink)ReflectionUtils.newInstance(configuration.getClass("hbase.canary.sink.class", + clazz, Sink.class)); + } + /** * A Factory method for {@link Monitor}. - * Can be overridden by user. + * Makes a RegionServerMonitor, or a ZooKeeperMonitor, or a RegionMonitor. * @param index a start index for monitor target * @param args args passed from user * @return a Monitor instance @@ -899,37 +941,45 @@ public Monitor newMonitor(final Connection connection, int index, String[] args) Monitor monitor = null; String[] monitorTargets = null; - if(index >= 0) { + if (index >= 0) { int length = args.length - index; monitorTargets = new String[length]; System.arraycopy(args, index, monitorTargets, 0, length); } - if (this.sink instanceof RegionServerStdOutSink || this.regionServerMode) { + if (this.regionServerMode) { monitor = new RegionServerMonitor(connection, monitorTargets, this.useRegExp, - (StdOutSink) this.sink, this.executor, this.regionServerAllRegions, + getSink(connection.getConfiguration(), RegionServerStdOutSink.class), + this.executor, this.regionServerAllRegions, this.treatFailureAsError, this.permittedFailures); - } else if (this.sink instanceof ZookeeperStdOutSink || this.zookeeperMode) { + } else if (this.zookeeperMode) { monitor = new ZookeeperMonitor(connection, monitorTargets, this.useRegExp, - (StdOutSink) this.sink, this.executor, this.treatFailureAsError, + getSink(connection.getConfiguration(), ZookeeperStdOutSink.class), + this.executor, this.treatFailureAsError, this.permittedFailures); } else { monitor = new RegionMonitor(connection, monitorTargets, this.useRegExp, - (StdOutSink) this.sink, this.executor, this.writeSniffing, + getSink(connection.getConfiguration(), RegionStdOutSink.class), + this.executor, this.writeSniffing, this.writeTableName, this.treatFailureAsError, this.configuredReadTableTimeouts, this.configuredWriteTableTimeout, this.permittedFailures); } return monitor; } - // a Monitor super-class can be extended by users + /** + * A Monitor super-class can be extended by users + */ public static abstract class Monitor implements Runnable, Closeable { - protected Connection connection; protected Admin admin; + /** + * 'Target' dependent on 'mode'. Could be Tables or RegionServers or ZNodes. + * Passed on the command-line as arguments. + */ protected String[] targets; protected boolean useRegExp; protected boolean treatFailureAsError; @@ -999,7 +1049,9 @@ protected boolean initAdmin() { } } - // a monitor for region mode + /** + * A monitor for region mode. + */ private static class RegionMonitor extends Monitor { // 10 minutes private static final int DEFAULT_WRITE_TABLE_CHECK_PERIOD = 10 * 60 * 1000; @@ -1014,14 +1066,22 @@ private static class RegionMonitor extends Monitor { private float regionsUpperLimit; private int checkPeriod; private boolean rawScanEnabled; + + /** + * This is a timeout per table. If read of each region in the table aggregated takes longer + * than what is configured here, we log an ERROR rather than just an INFO. + */ private HashMap configuredReadTableTimeouts; + private long configuredWriteTableTimeout; public RegionMonitor(Connection connection, String[] monitorTargets, boolean useRegExp, - StdOutSink sink, ExecutorService executor, boolean writeSniffing, TableName writeTableName, - boolean treatFailureAsError, HashMap configuredReadTableTimeouts, long configuredWriteTableTimeout, + Sink sink, ExecutorService executor, boolean writeSniffing, TableName writeTableName, + boolean treatFailureAsError, HashMap configuredReadTableTimeouts, + long configuredWriteTableTimeout, long allowedFailures) { - super(connection, monitorTargets, useRegExp, sink, executor, treatFailureAsError, allowedFailures); + super(connection, monitorTargets, useRegExp, sink, executor, treatFailureAsError, + allowedFailures); Configuration conf = connection.getConfiguration(); this.writeSniffing = writeSniffing; this.writeTableName = writeTableName; @@ -1054,9 +1114,12 @@ public void run() { RegionStdOutSink regionSink = this.getSink(); if (this.targets != null && this.targets.length > 0) { String[] tables = generateMonitorTables(this.targets); - // Check to see that each table name passed in the -readTableTimeouts argument is also passed as a monitor target. - if (! new HashSet<>(Arrays.asList(tables)).containsAll(this.configuredReadTableTimeouts.keySet())) { - LOG.error("-readTableTimeouts can only specify read timeouts for monitor targets passed via command line."); + // Check to see that each table name passed in the -readTableTimeouts argument is also + // passed as a monitor target. + if (!new HashSet<>(Arrays.asList(tables)). + containsAll(this.configuredReadTableTimeouts.keySet())) { + LOG.error("-readTableTimeouts can only specify read timeouts for monitor targets " + + "passed via command line."); this.errorCode = USAGE_EXIT_CODE; return; } @@ -1082,7 +1145,7 @@ public void run() { // sniff canary table with write operation regionSink.initializeWriteLatency(); LongAdder writeTableLatency = regionSink.getWriteLatency(); - taskFutures.addAll(Canary.sniff(admin, regionSink, admin.getTableDescriptor(writeTableName), + taskFutures.addAll(Canary.sniff(admin, regionSink, admin.getDescriptor(writeTableName), executor, TaskType.WRITE, this.rawScanEnabled, writeTableLatency)); } @@ -1099,23 +1162,26 @@ public void run() { if (actualReadTableLatency.containsKey(tableName)) { Long actual = actualReadTableLatency.get(tableName).longValue(); Long configured = entry.getValue(); - LOG.info("Read operation for " + tableName + " took " + actual + - " ms. The configured read timeout was " + configured + " ms."); if (actual > configured) { - LOG.error("Read operation for " + tableName + " exceeded the configured read timeout."); + LOG.error("Read operation for {} took {}ms (Configured read timeout {}ms.", + tableName, actual, configured); + } else { + LOG.info("Read operation for {} took {}ms (Configured read timeout {}ms.", + tableName, actual, configured); } } else { - LOG.error("Read operation for " + tableName + " failed!"); + LOG.error("Read operation for {} failed!", tableName); } } if (this.writeSniffing) { String writeTableStringName = this.writeTableName.getNameAsString(); long actualWriteLatency = regionSink.getWriteLatency().longValue(); - LOG.info("Write operation for " + writeTableStringName + " took " + actualWriteLatency + " ms. The configured write timeout was " + - this.configuredWriteTableTimeout + " ms."); + LOG.info("Write operation for {} took {}ms. Configured write timeout {}ms.", + writeTableStringName, actualWriteLatency, this.configuredWriteTableTimeout); // Check that the writeTable write operation latency does not exceed the configured timeout. if (actualWriteLatency > this.configuredWriteTableTimeout) { - LOG.error("Write operation for " + writeTableStringName + " exceeded the configured write timeout."); + LOG.error("Write operation for {} exceeded the configured write timeout.", + writeTableStringName); } } } catch (Exception e) { @@ -1123,31 +1189,32 @@ public void run() { this.errorCode = ERROR_EXIT_CODE; } finally { this.done = true; - } + } } this.done = true; } + /** + * @return List of tables to use in test. + */ private String[] generateMonitorTables(String[] monitorTargets) throws IOException { String[] returnTables = null; if (this.useRegExp) { Pattern pattern = null; - HTableDescriptor[] tds = null; + TableDescriptor[] tds = null; Set tmpTables = new TreeSet<>(); try { - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading list of tables")); - } + LOG.debug(String.format("reading list of tables")); tds = this.admin.listTables(pattern); if (tds == null) { - tds = new HTableDescriptor[0]; + tds = new TableDescriptor[0]; } for (String monitorTarget : monitorTargets) { pattern = Pattern.compile(monitorTarget); - for (HTableDescriptor td : tds) { - if (pattern.matcher(td.getNameAsString()).matches()) { - tmpTables.add(td.getNameAsString()); + for (TableDescriptor td : tds) { + if (pattern.matcher(td.getTableName().getNameAsString()).matches()) { + tmpTables.add(td.getTableName().getNameAsString()); } } } @@ -1172,18 +1239,19 @@ private String[] generateMonitorTables(String[] monitorTargets) throws IOExcepti } /* - * canary entry point to monitor all the tables. + * Canary entry point to monitor all the tables. */ - private List> sniff(TaskType taskType, RegionStdOutSink regionSink) throws Exception { - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading list of tables")); - } + private List> sniff(TaskType taskType, RegionStdOutSink regionSink) + throws Exception { + LOG.debug("Reading list of tables"); List> taskFutures = new LinkedList<>(); - for (HTableDescriptor table : admin.listTables()) { - if (admin.isTableEnabled(table.getTableName()) - && (!table.getTableName().equals(writeTableName))) { - LongAdder readLatency = regionSink.initializeAndGetReadLatencyForTable(table.getNameAsString()); - taskFutures.addAll(Canary.sniff(admin, sink, table, executor, taskType, this.rawScanEnabled, readLatency)); + for (TableDescriptor td: admin.listTableDescriptors()) { + if (admin.isTableEnabled(td.getTableName()) && + (!td.getTableName().equals(writeTableName))) { + LongAdder readLatency = + regionSink.initializeAndGetReadLatencyForTable(td.getTableName().getNameAsString()); + taskFutures.addAll(Canary.sniff(admin, sink, td, executor, taskType, this.rawScanEnabled, + readLatency)); } } return taskFutures; @@ -1231,11 +1299,10 @@ private void checkWriteTableDistribution() throws IOException { private void createWriteTable(int numberOfServers) throws IOException { int numberOfRegions = (int)(numberOfServers * regionsLowerLimit); - LOG.info("Number of live regionservers: " + numberOfServers + ", " - + "pre-splitting the canary table into " + numberOfRegions + " regions " - + "(current lower limit of regions per server is " + regionsLowerLimit - + " and you can change it by config: " - + HConstants.HBASE_CANARY_WRITE_PERSERVER_REGIONS_LOWERLIMIT_KEY + " )"); + LOG.info("Number of live regionservers {}, pre-splitting the canary table into {} regions " + + "(current lower limit of regions per server is {} and you can change it with config {}).", + numberOfServers, numberOfRegions, regionsLowerLimit, + HConstants.HBASE_CANARY_WRITE_PERSERVER_REGIONS_LOWERLIMIT_KEY); HTableDescriptor desc = new HTableDescriptor(writeTableName); HColumnDescriptor family = new HColumnDescriptor(CANARY_TABLE_FAMILY_NAME); family.setMaxVersions(1); @@ -1252,59 +1319,40 @@ private void createWriteTable(int numberOfServers) throws IOException { * @throws Exception */ private static List> sniff(final Admin admin, final Sink sink, String tableName, - ExecutorService executor, TaskType taskType, boolean rawScanEnabled, LongAdder readLatency) throws Exception { - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("checking table is enabled and getting table descriptor for table %s", - tableName)); - } + ExecutorService executor, TaskType taskType, boolean rawScanEnabled, LongAdder readLatency) + throws Exception { + LOG.debug("Checking table is enabled and getting table descriptor for table {}", tableName); if (admin.isTableEnabled(TableName.valueOf(tableName))) { - return Canary.sniff(admin, sink, admin.getTableDescriptor(TableName.valueOf(tableName)), + return Canary.sniff(admin, sink, admin.getDescriptor(TableName.valueOf(tableName)), executor, taskType, rawScanEnabled, readLatency); } else { - LOG.warn(String.format("Table %s is not enabled", tableName)); + LOG.warn("Table {} is not enabled", tableName); } return new LinkedList<>(); } /* - * Loops over regions that owns this table, and output some information about the state. + * Loops over regions of this table, and outputs information about the state. */ private static List> sniff(final Admin admin, final Sink sink, - HTableDescriptor tableDesc, ExecutorService executor, TaskType taskType, + TableDescriptor tableDesc, ExecutorService executor, TaskType taskType, boolean rawScanEnabled, LongAdder rwLatency) throws Exception { - - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading list of regions for table %s", tableDesc.getTableName())); - } - - Table table = null; - try { - table = admin.getConnection().getTable(tableDesc.getTableName()); - } catch (TableNotFoundException e) { - return new ArrayList<>(); - } - finally { - if (table !=null) { - table.close(); - } - } - - List tasks = new ArrayList<>(); - RegionLocator regionLocator = null; - try { - regionLocator = admin.getConnection().getRegionLocator(tableDesc.getTableName()); - for (HRegionLocation location : regionLocator.getAllRegionLocations()) { - ServerName rs = location.getServerName(); - RegionInfo region = location.getRegionInfo(); - tasks.add(new RegionTask(admin.getConnection(), region, rs, (RegionStdOutSink) sink, taskType, rawScanEnabled, - rwLatency)); - } - } finally { - if (regionLocator != null) { - regionLocator.close(); + LOG.debug("Reading list of regions for table {}", tableDesc.getTableName()); + try (Table table = admin.getConnection().getTable(tableDesc.getTableName())) { + List tasks = new ArrayList<>(); + try (RegionLocator regionLocator = + admin.getConnection().getRegionLocator(tableDesc.getTableName())) { + for (HRegionLocation location: regionLocator.getAllRegionLocations()) { + ServerName rs = location.getServerName(); + RegionInfo region = location.getRegion(); + tasks.add(new RegionTask(admin.getConnection(), region, rs, (RegionStdOutSink)sink, + taskType, rawScanEnabled, rwLatency)); + } + return executor.invokeAll(tasks); } + } catch (TableNotFoundException e) { + return Collections.EMPTY_LIST; } - return executor.invokeAll(tasks); } // monitor for zookeeper mode @@ -1314,8 +1362,9 @@ private static class ZookeeperMonitor extends Monitor { private final int timeout; protected ZookeeperMonitor(Connection connection, String[] monitorTargets, boolean useRegExp, - StdOutSink sink, ExecutorService executor, boolean treatFailureAsError, long allowedFailures) { - super(connection, monitorTargets, useRegExp, sink, executor, treatFailureAsError, allowedFailures); + Sink sink, ExecutorService executor, boolean treatFailureAsError, long allowedFailures) { + super(connection, monitorTargets, useRegExp, + sink, executor, treatFailureAsError, allowedFailures); Configuration configuration = connection.getConfiguration(); znode = configuration.get(ZOOKEEPER_ZNODE_PARENT, @@ -1374,15 +1423,17 @@ private ZookeeperStdOutSink getSink() { } - // a monitor for regionserver mode + /** + * A monitor for regionserver mode + */ private static class RegionServerMonitor extends Monitor { - private boolean allRegions; public RegionServerMonitor(Connection connection, String[] monitorTargets, boolean useRegExp, - StdOutSink sink, ExecutorService executor, boolean allRegions, + Sink sink, ExecutorService executor, boolean allRegions, boolean treatFailureAsError, long allowedFailures) { - super(connection, monitorTargets, useRegExp, sink, executor, treatFailureAsError, allowedFailures); + super(connection, monitorTargets, useRegExp, sink, executor, treatFailureAsError, + allowedFailures); this.allRegions = allRegions; } @@ -1413,10 +1464,7 @@ public void run() { private boolean checkNoTableNames() { List foundTableNames = new ArrayList<>(); TableName[] tableNames = null; - - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading list of tables")); - } + LOG.debug("Reading list of tables"); try { tableNames = this.admin.listTableNames(); } catch (IOException e) { @@ -1452,7 +1500,7 @@ private void monitorRegionServers(Map> rsAndRMap, Regio AtomicLong successes = new AtomicLong(0); successMap.put(serverName, successes); if (entry.getValue().isEmpty()) { - LOG.error(String.format("Regionserver not serving any regions - %s", serverName)); + LOG.error("Regionserver not serving any regions - {}", serverName); } else if (this.allRegions) { for (RegionInfo region : entry.getValue()) { tasks.add(new RegionServerTask(this.connection, @@ -1483,8 +1531,8 @@ private void monitorRegionServers(Map> rsAndRMap, Regio if (this.allRegions) { for (Map.Entry> entry : rsAndRMap.entrySet()) { String serverName = entry.getKey(); - LOG.info("Successfully read " + successMap.get(serverName) + " regions out of " - + entry.getValue().size() + " on regionserver:" + serverName); + LOG.info("Successfully read {} regions out of {} on regionserver {}", + successMap.get(serverName), entry.getValue().size(), serverName); } } } catch (InterruptedException e) { @@ -1501,36 +1549,30 @@ private Map> filterRegionServerByName() { private Map> getAllRegionServerByName() { Map> rsAndRMap = new HashMap<>(); - Table table = null; - RegionLocator regionLocator = null; try { - if (LOG.isDebugEnabled()) { - LOG.debug(String.format("reading list of tables and locations")); - } - HTableDescriptor[] tableDescs = this.admin.listTables(); + LOG.debug("Reading list of tables and locations"); + List tableDescs = this.admin.listTableDescriptors(); List regions = null; - for (HTableDescriptor tableDesc : tableDescs) { - table = this.admin.getConnection().getTable(tableDesc.getTableName()); - regionLocator = this.admin.getConnection().getRegionLocator(tableDesc.getTableName()); - - for (HRegionLocation location : regionLocator.getAllRegionLocations()) { - ServerName rs = location.getServerName(); - String rsName = rs.getHostname(); - RegionInfo r = location.getRegionInfo(); - - if (rsAndRMap.containsKey(rsName)) { - regions = rsAndRMap.get(rsName); - } else { - regions = new ArrayList<>(); - rsAndRMap.put(rsName, regions); + for (TableDescriptor tableDesc: tableDescs) { + try (RegionLocator regionLocator = + this.admin.getConnection().getRegionLocator(tableDesc.getTableName())) { + for (HRegionLocation location : regionLocator.getAllRegionLocations()) { + ServerName rs = location.getServerName(); + String rsName = rs.getHostname(); + RegionInfo r = location.getRegion(); + if (rsAndRMap.containsKey(rsName)) { + regions = rsAndRMap.get(rsName); + } else { + regions = new ArrayList<>(); + rsAndRMap.put(rsName, regions); + } + regions.add(r); } - regions.add(r); } - table.close(); } // get any live regionservers not serving any regions - for (ServerName rs : this.admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)) + for (ServerName rs: this.admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)) .getLiveServerMetrics().keySet()) { String rsName = rs.getHostname(); if (!rsAndRMap.containsKey(rsName)) { @@ -1538,19 +1580,9 @@ private Map> getAllRegionServerByName() { } } } catch (IOException e) { - String msg = "Get HTables info failed"; - LOG.error(msg, e); + LOG.error("Get HTables info failed", e); this.errorCode = INIT_ERROR_EXIT_CODE; - } finally { - if (table != null) { - try { - table.close(); - } catch (IOException e) { - LOG.warn("Close table failed", e); - } - } } - return rsAndRMap; } @@ -1576,13 +1608,13 @@ private Map> doFilterRegionServerByName( } } if (!regExpFound) { - LOG.info("No RegionServerInfo found, regionServerPattern:" + rsName); + LOG.info("No RegionServerInfo found, regionServerPattern {}", rsName); } } else { if (fullRsAndRMap.containsKey(rsName)) { filteredRsAndRMap.put(rsName, fullRsAndRMap.get(rsName)); } else { - LOG.info("No RegionServerInfo found, regionServerName:" + rsName); + LOG.info("No RegionServerInfo found, regionServerName {}", rsName); } } } @@ -1596,20 +1628,19 @@ private Map> doFilterRegionServerByName( public static void main(String[] args) throws Exception { final Configuration conf = HBaseConfiguration.create(); - // loading the generic options to conf + // Loading the generic options to conf new GenericOptionsParser(conf, args); int numThreads = conf.getInt("hbase.canary.threads.num", MAX_THREADS_NUM); - LOG.info("Number of execution threads " + numThreads); + LOG.info("Execution thread count={}", numThreads); + int exitCode = 0; ExecutorService executor = new ScheduledThreadPoolExecutor(numThreads); - - Class sinkClass = - conf.getClass("hbase.canary.sink.class", RegionServerStdOutSink.class, Sink.class); - Sink sink = ReflectionUtils.newInstance(sinkClass); - - int exitCode = ToolRunner.run(conf, new Canary(executor, sink), args); - executor.shutdown(); + try { + exitCode = ToolRunner.run(conf, new Canary(executor), args); + } finally { + executor.shutdown(); + } System.exit(exitCode); } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterChunk.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterChunk.java index d8fc3fb3c9d9..06cf699e34fe 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterChunk.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterChunk.java @@ -187,12 +187,12 @@ public void add(Cell cell) { int hash1; int hash2; HashKey hashKey; - if (this.bloomType == BloomType.ROW) { - hashKey = new RowBloomHashKey(cell); + if (this.bloomType == BloomType.ROWCOL) { + hashKey = new RowColBloomHashKey(cell); hash1 = this.hash.hash(hashKey, 0); hash2 = this.hash.hash(hashKey, hash1); } else { - hashKey = new RowColBloomHashKey(cell); + hashKey = new RowBloomHashKey(cell); hash1 = this.hash.hash(hashKey, 0); hash2 = this.hash.hash(hashKey, hash1); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterUtil.java index 33bea7a498c5..003f38444c33 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/BloomFilterUtil.java @@ -20,7 +20,9 @@ import java.text.NumberFormat; import java.util.Random; +import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; +import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.nio.ByteBuff; import org.apache.hadoop.hbase.regionserver.BloomType; import org.apache.yetus.audience.InterfaceAudience; @@ -46,6 +48,9 @@ public final class BloomFilterUtil { * estimate the ideal false positive rate. */ private static Random randomGeneratorForTest; + + public static final String PREFIX_LENGTH_KEY = "RowPrefixBloomFilter.prefix_length"; + public static final String DELIMITER_KEY = "RowPrefixDelimitedBloomFilter.delimiter"; /** Bit-value lookup array to prevent doing the same work over and over */ public static final byte [] bitvals = { @@ -239,8 +244,8 @@ private static boolean contains(ByteBuff bloomBuf, int bloomOffset, int bloo public static boolean contains(Cell cell, ByteBuff bloomBuf, int bloomOffset, int bloomSize, Hash hash, int hashCount, BloomType type) { - HashKey hashKey = type == BloomType.ROW ? new RowBloomHashKey(cell) - : new RowColBloomHashKey(cell); + HashKey hashKey = type == BloomType.ROWCOL ? new RowColBloomHashKey(cell) + : new RowBloomHashKey(cell); return contains(bloomBuf, bloomOffset, bloomSize, hash, hashCount, hashKey); } @@ -284,4 +289,45 @@ public static String toString(BloomFilterChunk bloomFilter) { return formatStats(bloomFilter) + STATS_RECORD_SEP + "Actual error rate: " + String.format("%.8f", bloomFilter.actualErrorRate()); } + + public static byte[] getBloomFilterParam(BloomType bloomFilterType, Configuration conf) + throws IllegalArgumentException{ + byte[] bloomParam = null; + String message = "Bloom filter type is " + bloomFilterType + ", "; + switch (bloomFilterType) { + case ROWPREFIX_FIXED_LENGTH: + String prefixLengthString = conf.get(PREFIX_LENGTH_KEY); + if (prefixLengthString == null) { + message += PREFIX_LENGTH_KEY + " not specified."; + throw new IllegalArgumentException(message); + } + int prefixLength; + try { + prefixLength = Integer.parseInt(prefixLengthString); + if (prefixLength <= 0 || prefixLength > HConstants.MAX_ROW_LENGTH) { + message += "the value of " + PREFIX_LENGTH_KEY + + " must >=0 and < " + HConstants.MAX_ROW_LENGTH; + throw new IllegalArgumentException(message); + } + } catch (NumberFormatException nfe) { + message = "Number format exception when parsing " + PREFIX_LENGTH_KEY + " for BloomType " + + bloomFilterType.toString() + ":" + + prefixLengthString; + throw new IllegalArgumentException(message, nfe); + } + bloomParam = Bytes.toBytes(prefixLength); + break; + case ROWPREFIX_DELIMITED: + String delimiterString = conf.get(DELIMITER_KEY); + if (delimiterString == null || delimiterString.length() == 0) { + message += DELIMITER_KEY + " not specified."; + throw new IllegalArgumentException(message); + } + bloomParam = Bytes.toBytes(delimiterString); + break; + default: + break; + } + return bloomParam; + } } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/JVMClusterUtil.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/JVMClusterUtil.java index ee7ecf3fad6f..8c92f6660c03 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/JVMClusterUtil.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/JVMClusterUtil.java @@ -23,12 +23,13 @@ import java.lang.reflect.Constructor; import java.lang.reflect.InvocationTargetException; import java.util.List; +import java.util.concurrent.TimeUnit; +import java.util.function.Supplier; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.hbase.CoordinatedStateManager; import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.regionserver.HRegionServer; @@ -162,6 +163,8 @@ private static JVMClusterUtil.MasterThread findActiveMaster( */ public static String startup(final List masters, final List regionservers) throws IOException { + // Implementation note: This method relies on timed sleeps in a loop. It's not great, and + // should probably be re-written to use actual synchronization objects, but it's ok for now Configuration configuration = null; @@ -177,21 +180,9 @@ public static String startup(final List masters, // Wait for an active master // having an active master before starting the region threads allows // then to succeed on their connection to master - long startTime = System.currentTimeMillis(); - while (findActiveMaster(masters) == null) { - try { - Thread.sleep(100); - } catch (InterruptedException e) { - throw (InterruptedIOException)new InterruptedIOException().initCause(e); - } - int startTimeout = configuration != null ? Integer.parseInt( + final int startTimeout = configuration != null ? Integer.parseInt( configuration.get("hbase.master.start.timeout.localHBaseCluster", "30000")) : 30000; - if (System.currentTimeMillis() > startTime + startTimeout) { - String msg = "Master not active after " + startTimeout + "ms"; - Threads.printThreadInfo(System.out, "Thread dump because: " + msg); - throw new RuntimeException(msg); - } - } + waitForEvent(startTimeout, "active", () -> findActiveMaster(masters) != null); if (regionservers != null) { for (JVMClusterUtil.RegionServerThread t: regionservers) { @@ -201,32 +192,50 @@ public static String startup(final List masters, // Wait for an active master to be initialized (implies being master) // with this, when we return the cluster is complete - startTime = System.currentTimeMillis(); - final int maxwait = 200000; - while (true) { - JVMClusterUtil.MasterThread t = findActiveMaster(masters); - if (t != null && t.master.isInitialized()) { - return t.master.getServerName().toString(); + final int initTimeout = configuration != null ? Integer.parseInt( + configuration.get("hbase.master.init.timeout.localHBaseCluster", "200000")) : 200000; + waitForEvent(initTimeout, "initialized", () -> { + JVMClusterUtil.MasterThread t = findActiveMaster(masters); + // master thread should never be null at this point, but let's keep the check anyway + return t != null && t.master.isInitialized(); } - // REMOVE - if (System.currentTimeMillis() > startTime + 10000) { - try { - Thread.sleep(1000); - } catch (InterruptedException e) { - throw (InterruptedIOException)new InterruptedIOException().initCause(e); - } + ); + + return findActiveMaster(masters).master.getServerName().toString(); + } + + /** + * Utility method to wait some time for an event to occur, and then return control to the caller. + * @param millis How long to wait, in milliseconds. + * @param action The action that we are waiting for. Will be used in log message if the event + * does not occur. + * @param check A Supplier that will be checked periodically to produce an updated true/false + * result indicating if the expected event has happened or not. + * @throws InterruptedIOException If we are interrupted while waiting for the event. + * @throws RuntimeException If we reach the specified timeout while waiting for the event. + */ + private static void waitForEvent(long millis, String action, Supplier check) + throws InterruptedIOException { + long end = System.nanoTime() + TimeUnit.MILLISECONDS.toNanos(millis); + + while (true) { + if (check.get()) { + return; } - if (System.currentTimeMillis() > startTime + maxwait) { - String msg = "Master not initialized after " + maxwait + "ms seconds"; + + if (System.nanoTime() > end) { + String msg = "Master not " + action + " after " + millis + "ms"; Threads.printThreadInfo(System.out, "Thread dump because: " + msg); throw new RuntimeException(msg); } + try { Thread.sleep(100); } catch (InterruptedException e) { throw (InterruptedIOException)new InterruptedIOException().initCause(e); } } + } /** diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionMover.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionMover.java index 54c71a104503..24c8fc339b1c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionMover.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RegionMover.java @@ -19,14 +19,17 @@ package org.apache.hadoop.hbase.util; -import java.io.BufferedReader; +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.Closeable; import java.io.DataInputStream; import java.io.DataOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; -import java.io.FileReader; import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Paths; import java.util.ArrayList; import java.util.Collections; import java.util.EnumSet; @@ -41,24 +44,23 @@ import java.util.concurrent.Future; import java.util.concurrent.TimeUnit; import java.util.concurrent.TimeoutException; +import java.util.function.Predicate; + +import org.apache.commons.io.IOUtils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.ClusterMetrics.Option; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.MetaTableAccessor; import org.apache.hadoop.hbase.ServerName; -import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; import org.apache.hadoop.hbase.client.Connection; import org.apache.hadoop.hbase.client.ConnectionFactory; -import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.RegionInfo; -import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter; -import org.apache.hadoop.hbase.zookeeper.MetaTableLocator; -import org.apache.hadoop.hbase.zookeeper.ZKWatcher; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -76,7 +78,7 @@ * {@link #load()} or {@link #unload()} methods for the desired operations. */ @InterfaceAudience.Public -public class RegionMover extends AbstractHBaseTool { +public class RegionMover extends AbstractHBaseTool implements Closeable { public static final String MOVE_RETRIES_MAX_KEY = "hbase.move.retries.max"; public static final String MOVE_WAIT_MAX_KEY = "hbase.move.wait.max"; public static final String SERVERSTART_WAIT_MAX_KEY = "hbase.serverstart.wait.max"; @@ -93,8 +95,10 @@ public class RegionMover extends AbstractHBaseTool { private String filename; private String excludeFile; private int port; + private Connection conn; + private Admin admin; - private RegionMover(RegionMoverBuilder builder) { + private RegionMover(RegionMoverBuilder builder) throws IOException { this.hostname = builder.hostname; this.filename = builder.filename; this.excludeFile = builder.excludeFile; @@ -103,11 +107,19 @@ private RegionMover(RegionMoverBuilder builder) { this.port = builder.port; this.timeout = builder.timeout; setConf(builder.conf); + this.conn = ConnectionFactory.createConnection(conf); + this.admin = conn.getAdmin(); } private RegionMover() { } + @Override + public void close() { + IOUtils.closeQuietly(this.admin); + IOUtils.closeQuietly(this.conn); + } + /** * Builder for Region mover. Use the {@link #build()} method to create RegionMover object. Has * {@link #filename(String)}, {@link #excludeFile(String)}, {@link #maxthreads(int)}, @@ -121,7 +133,6 @@ public static class RegionMoverBuilder { private String filename; private String excludeFile = null; private String defaultDir = System.getProperty("java.io.tmpdir"); - @VisibleForTesting final int port; private final Configuration conf; @@ -220,267 +231,225 @@ public RegionMoverBuilder timeout(int timeout) { * using load and unload methods * @return RegionMover object */ - public RegionMover build() { + public RegionMover build() throws IOException { return new RegionMover(this); } } /** - * Loads the specified {@link #hostname} with regions listed in the {@link #filename} RegionMover - * Object has to be created using {@link #RegionMover(RegionMoverBuilder)} - * @return true if loading succeeded, false otherwise - * @throws ExecutionException - * @throws InterruptedException if the loader thread was interrupted - * @throws TimeoutException + * Move Regions and make sure that they are up on the target server.If a region movement fails we + * exit as failure */ - public boolean load() throws ExecutionException, InterruptedException, TimeoutException { - ExecutorService loadPool = Executors.newFixedThreadPool(1); - Future loadTask = loadPool.submit(new Load(this)); - loadPool.shutdown(); - try { - if (!loadPool.awaitTermination((long) this.timeout, TimeUnit.SECONDS)) { - LOG.warn("Timed out before finishing the loading operation. Timeout:" + this.timeout - + "sec"); - loadPool.shutdownNow(); - } - } catch (InterruptedException e) { - loadPool.shutdownNow(); - Thread.currentThread().interrupt(); - } - try { - return loadTask.get(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - LOG.warn("Interrupted while loading Regions on " + this.hostname, e); - throw e; - } catch (ExecutionException e) { - LOG.error("Error while loading regions on RegionServer " + this.hostname, e); - throw e; - } - } - - private class Load implements Callable { - - private RegionMover rm; + private class MoveWithAck implements Callable { + private RegionInfo region; + private ServerName targetServer; + private List movedRegions; + private ServerName sourceServer; - public Load(RegionMover rm) { - this.rm = rm; + public MoveWithAck(RegionInfo regionInfo, ServerName sourceServer, + ServerName targetServer, List movedRegions) { + this.region = regionInfo; + this.targetServer = targetServer; + this.movedRegions = movedRegions; + this.sourceServer = sourceServer; } @Override - public Boolean call() throws IOException { - Connection conn = ConnectionFactory.createConnection(rm.conf); - try { - List regionsToMove = readRegionsFromFile(rm.filename); - if (regionsToMove.isEmpty()) { - LOG.info("No regions to load.Exiting"); - return true; + public Boolean call() throws IOException, InterruptedException { + boolean moved = false; + int count = 0; + int retries = admin.getConfiguration().getInt(MOVE_RETRIES_MAX_KEY, DEFAULT_MOVE_RETRIES_MAX); + int maxWaitInSeconds = + admin.getConfiguration().getInt(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); + long startTime = EnvironmentEdgeManager.currentTime(); + boolean sameServer = true; + // Assert we can scan the region in its current location + isSuccessfulScan(region); + LOG.info("Moving region:" + region.getEncodedName() + " from " + sourceServer + " to " + + targetServer); + while (count < retries && sameServer) { + if (count > 0) { + LOG.info("Retry " + Integer.toString(count) + " of maximum " + Integer.toString(retries)); } - Admin admin = conn.getAdmin(); - try { - loadRegions(admin, rm.hostname, rm.port, regionsToMove, rm.ack); - } finally { - admin.close(); + count = count + 1; + admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(targetServer.getServerName())); + long maxWait = startTime + (maxWaitInSeconds * 1000); + while (EnvironmentEdgeManager.currentTime() < maxWait) { + sameServer = isSameServer(region, sourceServer); + if (!sameServer) { + break; + } + Thread.sleep(100); } - } catch (Exception e) { - LOG.error("Error while loading regions to " + rm.hostname, e); - return false; - } finally { - conn.close(); } - return true; + if (sameServer) { + LOG.error("Region: " + region.getRegionNameAsString() + " stuck on " + this.sourceServer + + ",newServer=" + this.targetServer); + } else { + isSuccessfulScan(region); + LOG.info("Moved Region " + + region.getRegionNameAsString() + + " cost:" + + String.format("%.3f", + (float) (EnvironmentEdgeManager.currentTime() - startTime) / 1000)); + moved = true; + movedRegions.add(region); + } + return moved; } } /** - * Unload regions from given {@link #hostname} using ack/noAck mode and {@link #maxthreads}.In - * noAck mode we do not make sure that region is successfully online on the target region - * server,hence it is best effort.We do not unload regions to hostnames given in - * {@link #excludeFile}. - * @return true if unloading succeeded, false otherwise - * @throws InterruptedException if the unloader thread was interrupted - * @throws ExecutionException - * @throws TimeoutException + * Move Regions without Acknowledging.Usefule in case of RS shutdown as we might want to shut the + * RS down anyways and not abort on a stuck region. Improves movement performance */ - public boolean unload() throws InterruptedException, ExecutionException, TimeoutException { - deleteFile(this.filename); - ExecutorService unloadPool = Executors.newFixedThreadPool(1); - Future unloadTask = unloadPool.submit(new Unload(this)); - unloadPool.shutdown(); - try { - if (!unloadPool.awaitTermination((long) this.timeout, TimeUnit.SECONDS)) { - LOG.warn("Timed out before finishing the unloading operation. Timeout:" + this.timeout - + "sec"); - unloadPool.shutdownNow(); - } - } catch (InterruptedException e) { - unloadPool.shutdownNow(); - Thread.currentThread().interrupt(); - } - try { - return unloadTask.get(5, TimeUnit.SECONDS); - } catch (InterruptedException e) { - LOG.warn("Interrupted while unloading Regions from " + this.hostname, e); - throw e; - } catch (ExecutionException e) { - LOG.error("Error while unloading regions from RegionServer " + this.hostname, e); - throw e; - } - } - - private class Unload implements Callable { - - List movedRegions = Collections.synchronizedList(new ArrayList()); - private RegionMover rm; + private class MoveWithoutAck implements Callable { + private RegionInfo region; + private ServerName targetServer; + private List movedRegions; + private ServerName sourceServer; - public Unload(RegionMover rm) { - this.rm = rm; + public MoveWithoutAck(RegionInfo regionInfo, ServerName sourceServer, + ServerName targetServer, List movedRegions) { + this.region = regionInfo; + this.targetServer = targetServer; + this.movedRegions = movedRegions; + this.sourceServer = sourceServer; } @Override - public Boolean call() throws IOException { - Connection conn = ConnectionFactory.createConnection(rm.conf); + public Boolean call() { try { - Admin admin = conn.getAdmin(); - // Get Online RegionServers - ArrayList regionServers = getServers(admin); - if (LOG.isDebugEnabled()) { - LOG.debug("Online region servers:" + regionServers.toString()); - } - // Remove the host Region server from target Region Servers list - String server = stripServer(regionServers, hostname, port); - // Remove RS present in the exclude file - stripExcludes(regionServers, rm.excludeFile); - stripMaster(regionServers, admin); - unloadRegions(admin, server, regionServers, rm.ack, movedRegions); + LOG.info("Moving region:" + region.getEncodedName() + " from " + sourceServer + " to " + + targetServer); + admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(targetServer.getServerName())); + LOG.info("Moved " + region.getEncodedName() + " from " + sourceServer + " to " + + targetServer); } catch (Exception e) { - LOG.error("Error while unloading regions ", e); - return false; + LOG.error("Error Moving Region:" + region.getEncodedName(), e); } finally { - try { - conn.close(); - } catch (IOException e) { - // ignore - } - if (movedRegions != null) { - writeFile(rm.filename, movedRegions); - } + // we add region to the moved regions list in No Ack Mode since this is best effort + movedRegions.add(region); } return true; } } - private void loadRegions(Admin admin, String hostname, int port, - List regionsToMove, boolean ack) throws Exception { - String server = null; - List movedRegions = Collections.synchronizedList(new ArrayList()); - int maxWaitInSeconds = - admin.getConfiguration().getInt(SERVERSTART_WAIT_MAX_KEY, DEFAULT_SERVERSTART_WAIT_MAX); - long maxWait = EnvironmentEdgeManager.currentTime() + maxWaitInSeconds * 1000; - while ((EnvironmentEdgeManager.currentTime() < maxWait) && (server == null)) { + /** + * Loads the specified {@link #hostname} with regions listed in the {@link #filename} RegionMover + * Object has to be created using {@link #RegionMover(RegionMoverBuilder)} + * @return true if loading succeeded, false otherwise + */ + public boolean load() throws ExecutionException, InterruptedException, TimeoutException { + ExecutorService loadPool = Executors.newFixedThreadPool(1); + Future loadTask = loadPool.submit(() -> { try { - ArrayList regionServers = getServers(admin); - // Remove the host Region server from target Region Servers list - server = stripServer(regionServers, hostname, port); - if (server != null) { - break; + List regionsToMove = readRegionsFromFile(filename); + if (regionsToMove.isEmpty()) { + LOG.info("No regions to load.Exiting"); + return true; } - } catch (IOException e) { - LOG.warn("Could not get list of region servers", e); + loadRegions(regionsToMove); } catch (Exception e) { - LOG.info("hostname=" + hostname + " is not up yet, waiting"); - } - try { - Thread.sleep(500); - } catch (InterruptedException e) { - LOG.error("Interrupted while waiting for " + hostname + " to be up.Quitting now", e); - throw e; + LOG.error("Error while loading regions to " + hostname, e); + return false; } - } - if (server == null) { - LOG.error("Host:" + hostname + " is not up.Giving up."); - throw new Exception("Host to load regions not online"); - } - LOG.info("Moving " + regionsToMove.size() + " regions to " + server + " using " - + this.maxthreads + " threads.Ack mode:" + this.ack); + return true; + }); + return waitTaskToFinish(loadPool, loadTask, "loading"); + } + + private void loadRegions(List regionsToMove) + throws Exception { + ServerName server = getTargetServer(); + List movedRegions = Collections.synchronizedList(new ArrayList<>()); + LOG.info( + "Moving " + regionsToMove.size() + " regions to " + server + " using " + this.maxthreads + + " threads.Ack mode:" + this.ack); + ExecutorService moveRegionsPool = Executors.newFixedThreadPool(this.maxthreads); List> taskList = new ArrayList<>(); int counter = 0; while (counter < regionsToMove.size()) { RegionInfo region = regionsToMove.get(counter); - String currentServer = getServerNameForRegion(admin, region); + ServerName currentServer = getServerNameForRegion(region); if (currentServer == null) { - LOG.warn("Could not get server for Region:" + region.getEncodedName() + " moving on"); + LOG.warn( + "Could not get server for Region:" + region.getRegionNameAsString() + " moving on"); counter++; continue; } else if (server.equals(currentServer)) { - LOG.info("Region " + region.getRegionNameAsString() + - " is already on target server=" + server); + LOG.info( + "Region " + region.getRegionNameAsString() + " is already on target server=" + server); counter++; continue; } if (ack) { Future task = - moveRegionsPool.submit(new MoveWithAck(admin, region, currentServer, server, - movedRegions)); + moveRegionsPool.submit(new MoveWithAck(region, currentServer, server, movedRegions)); taskList.add(task); } else { Future task = - moveRegionsPool.submit(new MoveWithoutAck(admin, region, currentServer, server, - movedRegions)); + moveRegionsPool.submit(new MoveWithoutAck(region, currentServer, server, movedRegions)); taskList.add(task); } counter++; } + moveRegionsPool.shutdown(); - long timeoutInSeconds = - regionsToMove.size() - * admin.getConfiguration().getLong(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); - try { - if (!moveRegionsPool.awaitTermination(timeoutInSeconds, TimeUnit.SECONDS)) { - moveRegionsPool.shutdownNow(); - } - } catch (InterruptedException e) { - moveRegionsPool.shutdownNow(); - Thread.currentThread().interrupt(); - } - for (Future future : taskList) { + long timeoutInSeconds = regionsToMove.size() * admin.getConfiguration() + .getLong(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); + waitMoveTasksToFinish(moveRegionsPool, taskList, timeoutInSeconds); + } + + /** + * Unload regions from given {@link #hostname} using ack/noAck mode and {@link #maxthreads}.In + * noAck mode we do not make sure that region is successfully online on the target region + * server,hence it is best effort.We do not unload regions to hostnames given in + * {@link #excludeFile}. + * @return true if unloading succeeded, false otherwise + */ + public boolean unload() throws InterruptedException, ExecutionException, TimeoutException { + deleteFile(this.filename); + ExecutorService unloadPool = Executors.newFixedThreadPool(1); + Future unloadTask = unloadPool.submit(() -> { + List movedRegions = Collections.synchronizedList(new ArrayList<>()); try { - // if even after shutdownNow threads are stuck we wait for 5 secs max - if (!future.get(5, TimeUnit.SECONDS)) { - LOG.error("Was Not able to move region....Exiting Now"); - throw new Exception("Could not move region Exception"); + // Get Online RegionServers + List regionServers = new ArrayList<>(); + regionServers.addAll( + admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)).getLiveServerMetrics() + .keySet()); + // Remove the host Region server from target Region Servers list + ServerName server = stripServer(regionServers, hostname, port); + // Remove RS present in the exclude file + stripExcludes(regionServers); + stripMaster(regionServers); + if (regionServers.isEmpty()) { + LOG.warn("No Regions were moved - no servers available"); + return false; + } + unloadRegions(server, regionServers, movedRegions); + } catch (Exception e) { + LOG.error("Error while unloading regions ", e); + return false; + } finally { + if (movedRegions != null) { + writeFile(filename, movedRegions); } - } catch (InterruptedException e) { - LOG.error("Interrupted while waiting for Thread to Complete " + e.getMessage(), e); - throw e; - } catch (ExecutionException e) { - LOG.error("Got Exception From Thread While moving region " + e.getMessage(), e); - throw e; - } catch (CancellationException e) { - LOG.error("Thread for moving region cancelled. Timeout for cancellation:" - + timeoutInSeconds + "secs", e); - throw e; } - } + return true; + }); + return waitTaskToFinish(unloadPool, unloadTask, "unloading"); } - @edu.umd.cs.findbugs.annotations.SuppressWarnings(value="DLS_DEAD_LOCAL_STORE", - justification="FB is wrong; its size is read") - private void unloadRegions(Admin admin, String server, ArrayList regionServers, - boolean ack, List movedRegions) throws Exception { - List regionsToMove = new ArrayList<>();// FindBugs: DLS_DEAD_LOCAL_STORE - regionsToMove = getRegions(this.conf, server); - if (regionsToMove.isEmpty()) { - LOG.info("No Regions to move....Quitting now"); - return; - } else if (regionServers.isEmpty()) { - LOG.warn("No Regions were moved - no servers available"); - throw new Exception("No online region servers"); - } + private void unloadRegions(ServerName server, List regionServers, + List movedRegions) throws Exception { while (true) { - regionsToMove = getRegions(this.conf, server); + List regionsToMove = admin.getRegions(server); regionsToMove.removeAll(movedRegions); if (regionsToMove.isEmpty()) { + LOG.info("No Regions to move....Quitting now"); break; } int counter = 0; @@ -492,154 +461,110 @@ private void unloadRegions(Admin admin, String server, ArrayList regionS int serverIndex = 0; while (counter < regionsToMove.size()) { if (ack) { - Future task = - moveRegionsPool.submit(new MoveWithAck(admin, regionsToMove.get(counter), server, - regionServers.get(serverIndex), movedRegions)); + Future task = moveRegionsPool.submit( + new MoveWithAck(regionsToMove.get(counter), server, regionServers.get(serverIndex), + movedRegions)); taskList.add(task); } else { - Future task = - moveRegionsPool.submit(new MoveWithoutAck(admin, regionsToMove.get(counter), server, - regionServers.get(serverIndex), movedRegions)); + Future task = moveRegionsPool.submit( + new MoveWithoutAck(regionsToMove.get(counter), server, regionServers.get(serverIndex), + movedRegions)); taskList.add(task); } counter++; serverIndex = (serverIndex + 1) % regionServers.size(); } moveRegionsPool.shutdown(); - long timeoutInSeconds = - regionsToMove.size() - * admin.getConfiguration().getLong(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); - try { - if (!moveRegionsPool.awaitTermination(timeoutInSeconds, TimeUnit.SECONDS)) { - moveRegionsPool.shutdownNow(); - } - } catch (InterruptedException e) { - moveRegionsPool.shutdownNow(); - Thread.currentThread().interrupt(); - } - for (Future future : taskList) { - try { - // if even after shutdownNow threads are stuck we wait for 5 secs max - if (!future.get(5, TimeUnit.SECONDS)) { - LOG.error("Was Not able to move region....Exiting Now"); - throw new Exception("Could not move region Exception"); - } - } catch (InterruptedException e) { - LOG.error("Interrupted while waiting for Thread to Complete " + e.getMessage(), e); - throw e; - } catch (ExecutionException e) { - LOG.error("Got Exception From Thread While moving region " + e.getMessage(), e); - throw e; - } catch (CancellationException e) { - LOG.error("Thread for moving region cancelled. Timeout for cancellation:" - + timeoutInSeconds + "secs", e); - throw e; - } - } + long timeoutInSeconds = regionsToMove.size() * admin.getConfiguration() + .getLong(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); + waitMoveTasksToFinish(moveRegionsPool, taskList, timeoutInSeconds); } } - /** - * Move Regions and make sure that they are up on the target server.If a region movement fails we - * exit as failure - */ - private class MoveWithAck implements Callable { - private Admin admin; - private RegionInfo region; - private String targetServer; - private List movedRegions; - private String sourceServer; - - public MoveWithAck(Admin admin, RegionInfo regionInfo, String sourceServer, - String targetServer, List movedRegions) { - this.admin = admin; - this.region = regionInfo; - this.targetServer = targetServer; - this.movedRegions = movedRegions; - this.sourceServer = sourceServer; + private boolean waitTaskToFinish(ExecutorService pool, Future task, String operation) + throws TimeoutException, InterruptedException, ExecutionException { + pool.shutdown(); + try { + if (!pool.awaitTermination((long) this.timeout, TimeUnit.SECONDS)) { + LOG.warn( + "Timed out before finishing the " + operation + " operation. Timeout: " + this.timeout + + "sec"); + pool.shutdownNow(); + } + } catch (InterruptedException e) { + pool.shutdownNow(); + Thread.currentThread().interrupt(); } + try { + return task.get(5, TimeUnit.SECONDS); + } catch (InterruptedException e) { + LOG.warn("Interrupted while " + operation + " Regions on " + this.hostname, e); + throw e; + } catch (ExecutionException e) { + LOG.error("Error while " + operation + " regions on RegionServer " + this.hostname, e); + throw e; + } + } - @Override - public Boolean call() throws IOException, InterruptedException { - boolean moved = false; - int count = 0; - int retries = admin.getConfiguration().getInt(MOVE_RETRIES_MAX_KEY, DEFAULT_MOVE_RETRIES_MAX); - int maxWaitInSeconds = - admin.getConfiguration().getInt(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); - long startTime = EnvironmentEdgeManager.currentTime(); - boolean sameServer = true; - // Assert we can scan the region in its current location - isSuccessfulScan(admin, region); - LOG.info("Moving region:" + region.getEncodedName() + " from " + sourceServer + " to " - + targetServer); - while (count < retries && sameServer) { - if (count > 0) { - LOG.info("Retry " + Integer.toString(count) + " of maximum " + Integer.toString(retries)); - } - count = count + 1; - admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(targetServer)); - long maxWait = startTime + (maxWaitInSeconds * 1000); - while (EnvironmentEdgeManager.currentTime() < maxWait) { - sameServer = isSameServer(admin, region, sourceServer); - if (!sameServer) { - break; - } - Thread.sleep(100); - } + private void waitMoveTasksToFinish(ExecutorService moveRegionsPool, + List> taskList, long timeoutInSeconds) throws Exception { + try { + if (!moveRegionsPool.awaitTermination(timeoutInSeconds, TimeUnit.SECONDS)) { + moveRegionsPool.shutdownNow(); } - if (sameServer) { - LOG.error("Region: " + region.getRegionNameAsString() + " stuck on " + this.sourceServer - + ",newServer=" + this.targetServer); - } else { - isSuccessfulScan(admin, region); - LOG.info("Moved Region " - + region.getRegionNameAsString() - + " cost:" - + String.format("%.3f", - (float) (EnvironmentEdgeManager.currentTime() - startTime) / 1000)); - moved = true; - movedRegions.add(region); + } catch (InterruptedException e) { + moveRegionsPool.shutdownNow(); + Thread.currentThread().interrupt(); + } + for (Future future : taskList) { + try { + // if even after shutdownNow threads are stuck we wait for 5 secs max + if (!future.get(5, TimeUnit.SECONDS)) { + LOG.error("Was Not able to move region....Exiting Now"); + throw new Exception("Could not move region Exception"); + } + } catch (InterruptedException e) { + LOG.error("Interrupted while waiting for Thread to Complete " + e.getMessage(), e); + throw e; + } catch (ExecutionException e) { + LOG.error("Got Exception From Thread While moving region " + e.getMessage(), e); + throw e; + } catch (CancellationException e) { + LOG.error("Thread for moving region cancelled. Timeout for cancellation:" + timeoutInSeconds + + "secs", e); + throw e; } - return moved; } } - /** - * Move Regions without Acknowledging.Usefule in case of RS shutdown as we might want to shut the - * RS down anyways and not abort on a stuck region. Improves movement performance - */ - private static class MoveWithoutAck implements Callable { - private Admin admin; - private RegionInfo region; - private String targetServer; - private List movedRegions; - private String sourceServer; - - public MoveWithoutAck(Admin admin, RegionInfo regionInfo, String sourceServer, - String targetServer, List movedRegions) { - this.admin = admin; - this.region = regionInfo; - this.targetServer = targetServer; - this.movedRegions = movedRegions; - this.sourceServer = sourceServer; - } - - @Override - public Boolean call() { + private ServerName getTargetServer() throws Exception { + ServerName server = null; + int maxWaitInSeconds = + admin.getConfiguration().getInt(SERVERSTART_WAIT_MAX_KEY, DEFAULT_SERVERSTART_WAIT_MAX); + long maxWait = EnvironmentEdgeManager.currentTime() + maxWaitInSeconds * 1000; + while (EnvironmentEdgeManager.currentTime() < maxWait) { try { - LOG.info("Moving region:" + region.getEncodedName() + " from " + sourceServer + " to " - + targetServer); - admin.move(region.getEncodedNameAsBytes(), Bytes.toBytes(targetServer)); - LOG.info("Moved " + region.getEncodedName() + " from " + sourceServer + " to " - + targetServer); - } catch (Exception e) { - LOG.error("Error Moving Region:" + region.getEncodedName(), e); - } finally { - // we add region to the moved regions list in No Ack Mode since this is best effort - movedRegions.add(region); + List regionServers = new ArrayList<>(); + regionServers.addAll( + admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)).getLiveServerMetrics() + .keySet()); + // Remove the host Region server from target Region Servers list + server = stripServer(regionServers, hostname, port); + if (server != null) { + break; + } else { + LOG.warn("Server " + hostname + ":" + port + " is not up yet, waiting"); + } + } catch (IOException e) { + LOG.warn("Could not get list of region servers", e); } - return true; + Thread.sleep(500); + } + if (server == null) { + LOG.error("Server " + hostname + ":" + port + " is not up. Giving up."); + throw new Exception("Server " + hostname + ":" + port + " to load regions not online"); } + return server; } private List readRegionsFromFile(String filename) throws IOException { @@ -648,11 +573,8 @@ private List readRegionsFromFile(String filename) throws IOException if (!f.exists()) { return regions; } - FileInputStream fis = null; - DataInputStream dis = null; - try { - fis = new FileInputStream(f); - dis = new DataInputStream(fis); + try (DataInputStream dis = new DataInputStream( + new BufferedInputStream(new FileInputStream(f)))) { int numRegions = dis.readInt(); int index = 0; while (index < numRegions) { @@ -662,80 +584,66 @@ private List readRegionsFromFile(String filename) throws IOException } catch (IOException e) { LOG.error("Error while reading regions from file:" + filename, e); throw e; - } finally { - if (dis != null) { - dis.close(); - } - if (fis != null) { - fis.close(); - } } return regions; } - /** - * Get online regions of the passed server - * @param conf - * @param server - * @return List of Regions online on the server - * @throws IOException - */ - private List getRegions(Configuration conf, String server) throws IOException { - Connection conn = ConnectionFactory.createConnection(conf); - try { - return conn.getAdmin().getRegions(ServerName.valueOf(server)); - } finally { - conn.close(); - } - } - /** * Write the number of regions moved in the first line followed by regions moved in subsequent * lines - * @param filename - * @param movedRegions - * @throws IOException */ private void writeFile(String filename, List movedRegions) throws IOException { - FileOutputStream fos = null; - DataOutputStream dos = null; - try { - fos = new FileOutputStream(filename); - dos = new DataOutputStream(fos); + try (DataOutputStream dos = new DataOutputStream( + new BufferedOutputStream(new FileOutputStream(filename)))) { dos.writeInt(movedRegions.size()); for (RegionInfo region : movedRegions) { Bytes.writeByteArray(dos, RegionInfo.toByteArray(region)); } } catch (IOException e) { - LOG.error("ERROR: Was Not able to write regions moved to output file but moved " - + movedRegions.size() + " regions", e); + LOG.error( + "ERROR: Was Not able to write regions moved to output file but moved " + movedRegions + .size() + " regions", e); throw e; - } finally { - if (dos != null) { - dos.close(); - } - if (fos != null) { - fos.close(); + } + } + + private void deleteFile(String filename) { + File f = new File(filename); + if (f.exists()) { + f.delete(); + } + } + + /** + * @return List of servers from the exclude file in format 'hostname:port'. + */ + private List readExcludes(String excludeFile) throws IOException { + List excludeServers = new ArrayList<>(); + if (excludeFile == null) { + return excludeServers; + } else { + try { + Files.readAllLines(Paths.get(excludeFile)).stream().map(String::trim) + .filter(((Predicate) String::isEmpty).negate()).map(String::toLowerCase) + .forEach(excludeServers::add); + } catch (IOException e) { + LOG.warn("Exception while reading excludes file, continuing anyways", e); } + return excludeServers; } } /** * Excludes the servername whose hostname and port portion matches the list given in exclude file - * @param regionServers - * @param excludeFile - * @throws IOException */ - private void stripExcludes(ArrayList regionServers, String excludeFile) - throws IOException { + private void stripExcludes(List regionServers) throws IOException { if (excludeFile != null) { - ArrayList excludes = readExcludes(excludeFile); - Iterator i = regionServers.iterator(); + List excludes = readExcludes(excludeFile); + Iterator i = regionServers.iterator(); while (i.hasNext()) { - String rs = i.next(); - String rsPort = - rs.split(ServerName.SERVERNAME_SEPARATOR)[0] + ":" - + rs.split(ServerName.SERVERNAME_SEPARATOR)[1]; + String rs = i.next().getServerName(); + String rsPort = rs.split(ServerName.SERVERNAME_SEPARATOR)[0].toLowerCase() + ":" + rs + .split(ServerName.SERVERNAME_SEPARATOR)[1]; if (excludes.contains(rsPort)) { i.remove(); } @@ -747,127 +655,42 @@ private void stripExcludes(ArrayList regionServers, String excludeFile) /** * Exclude master from list of RSs to move regions to - * @param regionServers - * @param admin - * @throws IOException */ - private void stripMaster(ArrayList regionServers, Admin admin) throws IOException { + private void stripMaster(List regionServers) throws IOException { ServerName master = admin.getClusterMetrics(EnumSet.of(Option.MASTER)).getMasterName(); - String masterHostname = master.getHostname(); - int masterPort = master.getPort(); - try { - stripServer(regionServers, masterHostname, masterPort); - } catch (Exception e) { - LOG.warn("Could not remove master from list of RS", e); - } - } - - /** - * @return List of servers from the exclude file in format 'hostname:port'. - */ - private ArrayList readExcludes(String excludeFile) throws IOException { - ArrayList excludeServers = new ArrayList<>(); - if (excludeFile == null) { - return excludeServers; - } else { - File f = new File(excludeFile); - String line; - BufferedReader br = null; - try { - br = new BufferedReader(new FileReader(f)); - while ((line = br.readLine()) != null) { - line = line.trim(); - if (!line.equals("")) { - excludeServers.add(line); - } - } - } catch (IOException e) { - LOG.warn("Exception while reading excludes file,continuing anyways", e); - } finally { - if (br != null) { - br.close(); - } - } - return excludeServers; - } + stripServer(regionServers, master.getHostname(), master.getPort()); } /** * Remove the servername whose hostname and port portion matches from the passed array of servers. * Returns as side-effect the servername removed. - * @param regionServers - * @param hostname - * @param port * @return server removed from list of Region Servers - * @throws Exception */ - private String stripServer(ArrayList regionServers, String hostname, int port) - throws Exception { - String server = null; + private ServerName stripServer(List regionServers, String hostname, int port) { + ServerName server = null; String portString = Integer.toString(port); - Iterator i = regionServers.iterator(); - int noOfRs = regionServers.size(); + Iterator i = regionServers.iterator(); while (i.hasNext()) { server = i.next(); - String[] splitServer = server.split(ServerName.SERVERNAME_SEPARATOR); + String[] splitServer = server.getServerName().split(ServerName.SERVERNAME_SEPARATOR); if (splitServer[0].equalsIgnoreCase(hostname) && splitServer[1].equals(portString)) { i.remove(); return server; } } - if (regionServers.size() >= noOfRs) { - throw new Exception("Server " + hostname + ":" + Integer.toString(port) - + " is not in list of online servers(Offline/Incorrect)"); - } return server; } - /** - * Get Arraylist of Servers in the cluster - * @param admin - * @return ArrayList of online region servers - * @throws IOException - */ - private ArrayList getServers(Admin admin) throws IOException { - ArrayList serverInfo = new ArrayList<>( - admin.getClusterMetrics(EnumSet.of(Option.LIVE_SERVERS)).getLiveServerMetrics().keySet()); - ArrayList regionServers = new ArrayList<>(serverInfo.size()); - for (ServerName server : serverInfo) { - regionServers.add(server.getServerName().toLowerCase()); - } - return regionServers; - } - - private void deleteFile(String filename) { - File f = new File(filename); - if (f.exists()) { - f.delete(); - } - } - /** * Tries to scan a row from passed region - * @param admin - * @param region - * @throws IOException */ - private void isSuccessfulScan(Admin admin, RegionInfo region) throws IOException { - Scan scan = new Scan(region.getStartKey()); - scan.setBatch(1); - scan.setCaching(1); - scan.setFilter(new FirstKeyOnlyFilter()); - try { - Table table = admin.getConnection().getTable(region.getTable()); - try { - ResultScanner scanner = table.getScanner(scan); - try { - scanner.next(); - } finally { - scanner.close(); - } - } finally { - table.close(); - } + private void isSuccessfulScan(RegionInfo region) throws IOException { + Scan scan = new Scan().withStartRow(region.getStartKey()).setRaw(true).setOneRowLimit() + .setMaxResultSize(1L).setCaching(1).setFilter(new FirstKeyOnlyFilter()) + .setCacheBlocks(false); + try (Table table = conn.getTable(region.getTable()); + ResultScanner scanner = table.getScanner(scan)) { + scanner.next(); } catch (IOException e) { LOG.error("Could not scan region:" + region.getEncodedName(), e); throw e; @@ -876,15 +699,11 @@ private void isSuccessfulScan(Admin admin, RegionInfo region) throws IOException /** * Returns true if passed region is still on serverName when we look at hbase:meta. - * @param admin - * @param region - * @param serverName * @return true if region is hosted on serverName otherwise false - * @throws IOException */ - private boolean isSameServer(Admin admin, RegionInfo region, String serverName) + private boolean isSameServer(RegionInfo region, ServerName serverName) throws IOException { - String serverForRegion = getServerNameForRegion(admin, region); + ServerName serverForRegion = getServerNameForRegion(region); if (serverForRegion != null && serverForRegion.equals(serverName)) { return true; } @@ -894,55 +713,13 @@ private boolean isSameServer(Admin admin, RegionInfo region, String serverName) /** * Get servername that is up in hbase:meta hosting the given region. this is hostname + port + * startcode comma-delimited. Can return null - * @param admin - * @param region * @return regionServer hosting the given region - * @throws IOException */ - private String getServerNameForRegion(Admin admin, RegionInfo region) throws IOException { - String server = null; + private ServerName getServerNameForRegion(RegionInfo region) throws IOException { if (!admin.isTableEnabled(region.getTable())) { return null; } - if (region.isMetaRegion()) { - ZKWatcher zkw = new ZKWatcher(admin.getConfiguration(), "region_mover", null); - MetaTableLocator locator = new MetaTableLocator(); - int maxWaitInSeconds = - admin.getConfiguration().getInt(MOVE_WAIT_MAX_KEY, DEFAULT_MOVE_WAIT_MAX); - try { - server = locator.waitMetaRegionLocation(zkw, maxWaitInSeconds * 1000).toString(); - } catch (InterruptedException e) { - LOG.error("Interrupted while waiting for location of Meta", e); - } finally { - if (zkw != null) { - zkw.close(); - } - } - } else { - Table table = admin.getConnection().getTable(TableName.META_TABLE_NAME); - try { - Get get = new Get(region.getRegionName()); - get.addColumn(HConstants.CATALOG_FAMILY, HConstants.SERVER_QUALIFIER); - get.addColumn(HConstants.CATALOG_FAMILY, HConstants.STARTCODE_QUALIFIER); - Result result = table.get(get); - if (result != null) { - byte[] servername = - result.getValue(HConstants.CATALOG_FAMILY, HConstants.SERVER_QUALIFIER); - byte[] startcode = - result.getValue(HConstants.CATALOG_FAMILY, HConstants.STARTCODE_QUALIFIER); - if (servername != null) { - server = Bytes.toString(servername).replaceFirst(":", ",").toLowerCase() + "," + - Bytes.toLong(startcode); - } - } - } catch (IOException e) { - LOG.error("Could not get Server Name for region:" + region.getEncodedName(), e); - throw e; - } finally { - table.close(); - } - } - return server; + return MetaTableAccessor.getRegionLocation(conn, region).getServerName(); } @Override @@ -950,18 +727,18 @@ protected void addOptions() { this.addRequiredOptWithArg("r", "regionserverhost", "region server |"); this.addRequiredOptWithArg("o", "operation", "Expected: load/unload"); this.addOptWithArg("m", "maxthreads", - "Define the maximum number of threads to use to unload and reload the regions"); + "Define the maximum number of threads to use to unload and reload the regions"); this.addOptWithArg("x", "excludefile", - "File with per line to exclude as unload targets; default excludes only " - + "target host; useful for rack decommisioning."); + "File with per line to exclude as unload targets; default excludes only " + + "target host; useful for rack decommisioning."); this.addOptWithArg("f", "filename", - "File to save regions list into unloading, or read from loading; " - + "default /tmp/"); + "File to save regions list into unloading, or read from loading; " + + "default /tmp/"); this.addOptNoArg("n", "noack", - "Turn on No-Ack mode(default: false) which won't check if region is online on target " - + "RegionServer, hence best effort. This is more performant in unloading and loading " - + "but might lead to region being unavailable for some time till master reassigns it " - + "in case the move failed"); + "Turn on No-Ack mode(default: false) which won't check if region is online on target " + + "RegionServer, hence best effort. This is more performant in unloading and loading " + + "but might lead to region being unavailable for some time till master reassigns it " + + "in case the move failed"); this.addOptWithArg("t", "timeout", "timeout in seconds after which the tool will exit " + "irrespective of whether it finished or not;default Integer.MAX_VALUE"); } @@ -991,14 +768,15 @@ protected void processOptions(CommandLine cmd) { @Override protected int doWork() throws Exception { boolean success; - RegionMover rm = rmbuilder.build(); - if (loadUnload.equalsIgnoreCase("load")) { - success = rm.load(); - } else if (loadUnload.equalsIgnoreCase("unload")) { - success = rm.unload(); - } else { - printUsage(); - success = false; + try (RegionMover rm = rmbuilder.build()) { + if (loadUnload.equalsIgnoreCase("load")) { + success = rm.load(); + } else if (loadUnload.equalsIgnoreCase("unload")) { + success = rm.unload(); + } else { + printUsage(); + success = false; + } } return (success ? 0 : 1); } @@ -1006,4 +784,4 @@ protected int doWork() throws Exception { public static void main(String[] args) { new RegionMover().doStaticMain(args); } -} +} \ No newline at end of file diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RowPrefixDelimiterBloomContext.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RowPrefixDelimiterBloomContext.java new file mode 100644 index 000000000000..5fcf43b114ed --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RowPrefixDelimiterBloomContext.java @@ -0,0 +1,62 @@ +/** + * 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.util; + +import java.io.IOException; + +import org.apache.hadoop.hbase.Cell; +import org.apache.hadoop.hbase.CellBuilderType; +import org.apache.hadoop.hbase.CellComparator; +import org.apache.hadoop.hbase.CellUtil; +import org.apache.hadoop.hbase.ExtendedCellBuilderFactory; +import org.apache.yetus.audience.InterfaceAudience; + +/** + * Handles ROWPREFIX_DELIMITED bloom related context. + * It works with both ByteBufferedCell and byte[] backed cells + */ +@InterfaceAudience.Private +public class RowPrefixDelimiterBloomContext extends RowBloomContext { + private final byte[] delimiter; + + public RowPrefixDelimiterBloomContext(BloomFilterWriter bloomFilterWriter, + CellComparator comparator, byte[] delimiter) { + super(bloomFilterWriter, comparator); + this.delimiter = delimiter; + } + + public void writeBloom(Cell cell) throws IOException { + super.writeBloom(getDelimitedRowPrefixCell(cell)); + } + + /** + * @param cell the new cell + * @return the new cell created by delimited row prefix + */ + private Cell getDelimitedRowPrefixCell(Cell cell) { + byte[] row = CellUtil.copyRow(cell); + int prefixLength = Bytes.indexOf(row, delimiter); + if (prefixLength <= 0) { + return cell; + } + return ExtendedCellBuilderFactory.create(CellBuilderType.DEEP_COPY) + .setRow(row, 0, Math.min(prefixLength, row.length)) + .setType(Cell.Type.Put) + .build(); + } +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RowPrefixFixedLengthBloomContext.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RowPrefixFixedLengthBloomContext.java new file mode 100644 index 000000000000..5abbf1c159c7 --- /dev/null +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/util/RowPrefixFixedLengthBloomContext.java @@ -0,0 +1,58 @@ +/** + * 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.util; + +import java.io.IOException; + +import org.apache.hadoop.hbase.Cell; +import org.apache.hadoop.hbase.CellBuilderType; +import org.apache.hadoop.hbase.CellComparator; +import org.apache.hadoop.hbase.CellUtil; +import org.apache.hadoop.hbase.ExtendedCellBuilderFactory; +import org.apache.yetus.audience.InterfaceAudience; + +/** + * Handles ROWPREFIX bloom related context. + * It works with both ByteBufferedCell and byte[] backed cells + */ +@InterfaceAudience.Private +public class RowPrefixFixedLengthBloomContext extends RowBloomContext { + private final int prefixLength; + + public RowPrefixFixedLengthBloomContext(BloomFilterWriter bloomFilterWriter, + CellComparator comparator, int prefixLength) { + super(bloomFilterWriter, comparator); + this.prefixLength = prefixLength; + } + + public void writeBloom(Cell cell) throws IOException { + super.writeBloom(getRowPrefixCell(cell)); + } + + /** + * @param cell the cell + * @return the new cell created by row prefix + */ + private Cell getRowPrefixCell(Cell cell) { + byte[] row = CellUtil.copyRow(cell); + return ExtendedCellBuilderFactory.create(CellBuilderType.DEEP_COPY) + .setRow(row, 0, Math.min(prefixLength, row.length)) + .setType(Cell.Type.Put) + .build(); + } +} diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALPrettyPrinter.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALPrettyPrinter.java index 3fa496fea1ae..281f3c9c1d73 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALPrettyPrinter.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALPrettyPrinter.java @@ -84,6 +84,8 @@ public class WALPrettyPrinter { private PrintStream out; // for JSON encoding private static final ObjectMapper MAPPER = new ObjectMapper(); + //allows for jumping straight to a given portion of the file + private long position; /** * Basic constructor that simply initializes values to reasonable defaults. @@ -201,6 +203,15 @@ public void setRowFilter(String row) { this.row = row; } + /** + * sets the position to start seeking the WAL file + * @param position + * initial position to start seeking the given WAL file + */ + public void setPosition(long position) { + this.position = position; + } + /** * enables output as a single, persistent list. at present, only relevant in * the case of JSON output. @@ -274,6 +285,10 @@ public void processFile(final Configuration conf, final Path p) firstTxn = true; } + if (position > 0) { + log.seek(position); + } + try { WAL.Entry entry; while ((entry = log.next()) != null) { @@ -297,6 +312,7 @@ public void processFile(final Configuration conf, final Path p) if (row == null || ((String) op.get("row")).equals(row)) { actions.add(op); } + op.put("total_size_sum", PrivateCellUtil.estimatedSizeOfCell(cell)); } if (actions.isEmpty()) continue; @@ -321,8 +337,11 @@ public void processFile(final Configuration conf, final Path p) out.println(" tag: " + op.get("tag")); } if (outputValues) out.println(" value: " + op.get("value")); + out.println("cell total size sum: " + op.get("total_size_sum")); } } + out.println("edit heap size: " + entry.getEdit().heapSize()); + out.println("position: " + log.getPosition()); } } finally { log.close(); @@ -380,6 +399,7 @@ public static void run(String[] args) throws IOException { options.addOption("s", "sequence", true, "Sequence to filter by. Pass sequence number."); options.addOption("w", "row", true, "Row to filter by. Pass row name."); + options.addOption("g", "goto", true, "Position to seek to in the file"); WALPrettyPrinter printer = new WALPrettyPrinter(); CommandLineParser parser = new PosixParser(); @@ -403,6 +423,9 @@ public static void run(String[] args) throws IOException { printer.setSequenceFilter(Long.parseLong(cmd.getOptionValue("s"))); if (cmd.hasOption("w")) printer.setRowFilter(cmd.getOptionValue("w")); + if (cmd.hasOption("g")) { + printer.setPosition(Long.parseLong(cmd.getOptionValue("g"))); + } } catch (ParseException e) { LOG.error("Failed to parse commandLine arguments", e); HelpFormatter formatter = new HelpFormatter(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALSplitter.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALSplitter.java index ac327c5b0a22..bc67d9863d8a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALSplitter.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/wal/WALSplitter.java @@ -117,7 +117,7 @@ public class WALSplitter { // Parameters for split process protected final Path walDir; - protected final FileSystem fs; + protected final FileSystem walFS; protected final Configuration conf; // Major subcomponents of the split process. @@ -150,14 +150,14 @@ public class WALSplitter { @VisibleForTesting WALSplitter(final WALFactory factory, Configuration conf, Path walDir, - FileSystem fs, LastSequenceId idChecker, + FileSystem walFS, LastSequenceId idChecker, SplitLogWorkerCoordination splitLogWorkerCoordination) { this.conf = HBaseConfiguration.create(conf); String codecClassName = conf .get(WALCellCodec.WAL_CELL_CODEC_CLASS_KEY, WALCellCodec.class.getName()); this.conf.set(HConstants.RPC_CODEC_CONF_KEY, codecClassName); this.walDir = walDir; - this.fs = fs; + this.walFS = walFS; this.sequenceIdChecker = idChecker; this.splitLogWorkerCoordination = splitLogWorkerCoordination; @@ -187,11 +187,11 @@ public class WALSplitter { *

    * @return false if it is interrupted by the progress-able. */ - public static boolean splitLogFile(Path walDir, FileStatus logfile, FileSystem fs, + public static boolean splitLogFile(Path walDir, FileStatus logfile, FileSystem walFS, Configuration conf, CancelableProgressable reporter, LastSequenceId idChecker, SplitLogWorkerCoordination splitLogWorkerCoordination, final WALFactory factory) throws IOException { - WALSplitter s = new WALSplitter(factory, conf, walDir, fs, idChecker, + WALSplitter s = new WALSplitter(factory, conf, walDir, walFS, idChecker, splitLogWorkerCoordination); return s.splitLogFile(logfile, reporter); } @@ -202,13 +202,13 @@ public static boolean splitLogFile(Path walDir, FileStatus logfile, FileSystem f // which uses this method to do log splitting. @VisibleForTesting public static List split(Path rootDir, Path logDir, Path oldLogDir, - FileSystem fs, Configuration conf, final WALFactory factory) throws IOException { + FileSystem walFS, Configuration conf, final WALFactory factory) throws IOException { final FileStatus[] logfiles = SplitLogManager.getFileList(conf, Collections.singletonList(logDir), null); List splits = new ArrayList<>(); if (ArrayUtils.isNotEmpty(logfiles)) { for (FileStatus logfile: logfiles) { - WALSplitter s = new WALSplitter(factory, conf, rootDir, fs, null, null); + WALSplitter s = new WALSplitter(factory, conf, rootDir, walFS, null, null); if (s.splitLogFile(logfile, null)) { finishSplitLogFile(rootDir, oldLogDir, logfile.getPath(), conf); if (s.outputSink.splits != null) { @@ -217,7 +217,7 @@ public static List split(Path rootDir, Path logDir, Path oldLogDir, } } } - if (!fs.delete(logDir, true)) { + if (!walFS.delete(logDir, true)) { throw new IOException("Unable to delete src dir: " + logDir); } return splits; @@ -323,10 +323,10 @@ boolean splitLogFile(FileStatus logfile, CancelableProgressable reporter) throws LOG.warn("Could not parse, corrupted WAL={}", logPath, e); if (splitLogWorkerCoordination != null) { // Some tests pass in a csm of null. - splitLogWorkerCoordination.markCorrupted(walDir, logfile.getPath().getName(), fs); + splitLogWorkerCoordination.markCorrupted(walDir, logfile.getPath().getName(), walFS); } else { // for tests only - ZKSplitLog.markCorrupted(walDir, logfile.getPath().getName(), fs); + ZKSplitLog.markCorrupted(walDir, logfile.getPath().getName(), walFS); } isCorrupted = true; } catch (IOException e) { @@ -374,31 +374,30 @@ boolean splitLogFile(FileStatus logfile, CancelableProgressable reporter) throws */ public static void finishSplitLogFile(String logfile, Configuration conf) throws IOException { - Path rootdir = FSUtils.getWALRootDir(conf); - Path oldLogDir = new Path(rootdir, HConstants.HREGION_OLDLOGDIR_NAME); + Path walDir = FSUtils.getWALRootDir(conf); + Path oldLogDir = new Path(walDir, HConstants.HREGION_OLDLOGDIR_NAME); Path logPath; - if (FSUtils.isStartingWithPath(rootdir, logfile)) { + if (FSUtils.isStartingWithPath(walDir, logfile)) { logPath = new Path(logfile); } else { - logPath = new Path(rootdir, logfile); + logPath = new Path(walDir, logfile); } - finishSplitLogFile(rootdir, oldLogDir, logPath, conf); + finishSplitLogFile(walDir, oldLogDir, logPath, conf); } - private static void finishSplitLogFile(Path rootdir, Path oldLogDir, + private static void finishSplitLogFile(Path walDir, Path oldLogDir, Path logPath, Configuration conf) throws IOException { List processedLogs = new ArrayList<>(); List corruptedLogs = new ArrayList<>(); - FileSystem fs; - fs = rootdir.getFileSystem(conf); - if (ZKSplitLog.isCorrupted(rootdir, logPath.getName(), fs)) { + FileSystem walFS = walDir.getFileSystem(conf); + if (ZKSplitLog.isCorrupted(walDir, logPath.getName(), walFS)) { corruptedLogs.add(logPath); } else { processedLogs.add(logPath); } - archiveLogs(corruptedLogs, processedLogs, oldLogDir, fs, conf); - Path stagingDir = ZKSplitLog.getSplitLogDir(rootdir, logPath.getName()); - fs.delete(stagingDir, true); + archiveLogs(corruptedLogs, processedLogs, oldLogDir, walFS, conf); + Path stagingDir = ZKSplitLog.getSplitLogDir(walDir, logPath.getName()); + walFS.delete(stagingDir, true); } /** @@ -409,30 +408,30 @@ private static void finishSplitLogFile(Path rootdir, Path oldLogDir, * @param corruptedLogs * @param processedLogs * @param oldLogDir - * @param fs + * @param walFS WAL FileSystem to archive files on. * @param conf * @throws IOException */ private static void archiveLogs( final List corruptedLogs, final List processedLogs, final Path oldLogDir, - final FileSystem fs, final Configuration conf) throws IOException { + final FileSystem walFS, final Configuration conf) throws IOException { final Path corruptDir = new Path(FSUtils.getWALRootDir(conf), HConstants.CORRUPT_DIR_NAME); if (conf.get("hbase.regionserver.hlog.splitlog.corrupt.dir") != null) { LOG.warn("hbase.regionserver.hlog.splitlog.corrupt.dir is deprecated. Default to {}", corruptDir); } - if (!fs.mkdirs(corruptDir)) { + if (!walFS.mkdirs(corruptDir)) { LOG.info("Unable to mkdir {}", corruptDir); } - fs.mkdirs(oldLogDir); + walFS.mkdirs(oldLogDir); // this method can get restarted or called multiple times for archiving // the same log files. for (Path corrupted : corruptedLogs) { Path p = new Path(corruptDir, corrupted.getName()); - if (fs.exists(corrupted)) { - if (!fs.rename(corrupted, p)) { + if (walFS.exists(corrupted)) { + if (!walFS.rename(corrupted, p)) { LOG.warn("Unable to move corrupted log {} to {}", corrupted, p); } else { LOG.warn("Moved corrupted log {} to {}", corrupted, p); @@ -442,8 +441,8 @@ private static void archiveLogs( for (Path p : processedLogs) { Path newPath = AbstractFSWAL.getWALArchivePath(oldLogDir, p); - if (fs.exists(p)) { - if (!FSUtils.renameAndSetModifyTime(fs, p, newPath)) { + if (walFS.exists(p)) { + if (!FSUtils.renameAndSetModifyTime(walFS, p, newPath)) { LOG.warn("Unable to move {} to {}", p, newPath); } else { LOG.info("Archived processed log {} to {}", p, newPath); @@ -469,35 +468,29 @@ private static void archiveLogs( @VisibleForTesting static Path getRegionSplitEditsPath(final Entry logEntry, String fileNameBeingSplit, String tmpDirName, Configuration conf) throws IOException { - FileSystem fs = FileSystem.get(conf); - Path rootDir = FSUtils.getRootDir(conf); - Path tableDir = FSUtils.getTableDir(rootDir, logEntry.getKey().getTableName()); + FileSystem walFS = FSUtils.getWALFileSystem(conf); + Path tableDir = FSUtils.getWALTableDir(conf, logEntry.getKey().getTableName()); String encodedRegionName = Bytes.toString(logEntry.getKey().getEncodedRegionName()); - Path regiondir = HRegion.getRegionDir(tableDir, encodedRegionName); - Path dir = getRegionDirRecoveredEditsDir(regiondir); + Path regionDir = HRegion.getRegionDir(tableDir, encodedRegionName); + Path dir = getRegionDirRecoveredEditsDir(regionDir); - if (!fs.exists(regiondir)) { - LOG.info("This region's directory does not exist: {}." - + "It is very likely that it was already split so it is " - + "safe to discard those edits.", regiondir); - return null; - } - if (fs.exists(dir) && fs.isFile(dir)) { + + if (walFS.exists(dir) && walFS.isFile(dir)) { Path tmp = new Path(tmpDirName); - if (!fs.exists(tmp)) { - fs.mkdirs(tmp); + if (!walFS.exists(tmp)) { + walFS.mkdirs(tmp); } tmp = new Path(tmp, HConstants.RECOVERED_EDITS_DIR + "_" + encodedRegionName); LOG.warn("Found existing old file: {}. It could be some " + "leftover of an old installation. It should be a folder instead. " + "So moving it to {}", dir, tmp); - if (!fs.rename(dir, tmp)) { + if (!walFS.rename(dir, tmp)) { LOG.warn("Failed to sideline old file {}", dir); } } - if (!fs.exists(dir) && !fs.mkdirs(dir)) { + if (!walFS.exists(dir) && !walFS.mkdirs(dir)) { LOG.warn("mkdir failed on {}", dir); } // Append fileBeingSplit to prevent name conflict since we may have duplicate wal entries now. @@ -535,34 +528,34 @@ static String formatRecoveredEditsFileName(final long seqid) { private static final String RECOVERED_LOG_TMPFILE_SUFFIX = ".temp"; /** - * @param regiondir + * @param regionDir * This regions directory in the filesystem. * @return The directory that holds recovered edits files for the region - * regiondir + * regionDir */ - public static Path getRegionDirRecoveredEditsDir(final Path regiondir) { - return new Path(regiondir, HConstants.RECOVERED_EDITS_DIR); + public static Path getRegionDirRecoveredEditsDir(final Path regionDir) { + return new Path(regionDir, HConstants.RECOVERED_EDITS_DIR); } /** * Check whether there is recovered.edits in the region dir - * @param fs FileSystem + * @param walFS FileSystem * @param conf conf * @param regionInfo the region to check * @throws IOException IOException * @return true if recovered.edits exist in the region dir */ - public static boolean hasRecoveredEdits(final FileSystem fs, + public static boolean hasRecoveredEdits(final FileSystem walFS, final Configuration conf, final RegionInfo regionInfo) throws IOException { // No recovered.edits for non default replica regions if (regionInfo.getReplicaId() != RegionInfo.DEFAULT_REPLICA_ID) { return false; } - Path rootDir = FSUtils.getRootDir(conf); //Only default replica region can reach here, so we can use regioninfo //directly without converting it to default replica's regioninfo. - Path regionDir = HRegion.getRegionDir(rootDir, regionInfo); - NavigableSet files = getSplitEditFilesSorted(fs, regionDir); + Path regionDir = FSUtils.getWALRegionDir(conf, regionInfo.getTable(), + regionInfo.getEncodedName()); + NavigableSet files = getSplitEditFilesSorted(walFS, regionDir); return files != null && !files.isEmpty(); } @@ -571,19 +564,19 @@ public static boolean hasRecoveredEdits(final FileSystem fs, * Returns sorted set of edit files made by splitter, excluding files * with '.temp' suffix. * - * @param fs - * @param regiondir - * @return Files in passed regiondir as a sorted set. + * @param walFS WAL FileSystem used to retrieving split edits files. + * @param regionDir WAL region dir to look for recovered edits files under. + * @return Files in passed regionDir as a sorted set. * @throws IOException */ - public static NavigableSet getSplitEditFilesSorted(final FileSystem fs, - final Path regiondir) throws IOException { + public static NavigableSet getSplitEditFilesSorted(final FileSystem walFS, + final Path regionDir) throws IOException { NavigableSet filesSorted = new TreeSet<>(); - Path editsdir = getRegionDirRecoveredEditsDir(regiondir); - if (!fs.exists(editsdir)) { + Path editsdir = getRegionDirRecoveredEditsDir(regionDir); + if (!walFS.exists(editsdir)) { return filesSorted; } - FileStatus[] files = FSUtils.listStatus(fs, editsdir, new PathFilter() { + FileStatus[] files = FSUtils.listStatus(walFS, editsdir, new PathFilter() { @Override public boolean accept(Path p) { boolean result = false; @@ -593,7 +586,7 @@ public boolean accept(Path p) { // In particular, on error, we'll move aside the bad edit file giving // it a timestamp suffix. See moveAsideBadEditsFile. Matcher m = EDITFILES_NAME_PATTERN.matcher(p.getName()); - result = fs.isFile(p) && m.matches(); + result = walFS.isFile(p) && m.matches(); // Skip the file whose name ends with RECOVERED_LOG_TMPFILE_SUFFIX, // because it means splitwal thread is writting this file. if (p.getName().endsWith(RECOVERED_LOG_TMPFILE_SUFFIX)) { @@ -618,17 +611,17 @@ public boolean accept(Path p) { /** * Move aside a bad edits file. * - * @param fs + * @param walFS WAL FileSystem used to rename bad edits file. * @param edits * Edits file to move aside. * @return The name of the moved aside file. * @throws IOException */ - public static Path moveAsideBadEditsFile(final FileSystem fs, final Path edits) + public static Path moveAsideBadEditsFile(final FileSystem walFS, final Path edits) throws IOException { Path moveAsideName = new Path(edits.getParent(), edits.getName() + "." + System.currentTimeMillis()); - if (!fs.rename(edits, moveAsideName)) { + if (!walFS.rename(edits, moveAsideName)) { LOG.warn("Rename failed from {} to {}", edits, moveAsideName); } return moveAsideName; @@ -647,12 +640,13 @@ public static boolean isSequenceIdFile(final Path file) { || file.getName().endsWith(OLD_SEQUENCE_ID_FILE_SUFFIX); } - private static FileStatus[] getSequenceIdFiles(FileSystem fs, Path regionDir) throws IOException { + private static FileStatus[] getSequenceIdFiles(FileSystem walFS, Path regionDir) + throws IOException { // TODO: Why are we using a method in here as part of our normal region open where // there is no splitting involved? Fix. St.Ack 01/20/2017. Path editsDir = WALSplitter.getRegionDirRecoveredEditsDir(regionDir); try { - FileStatus[] files = fs.listStatus(editsDir, WALSplitter::isSequenceIdFile); + FileStatus[] files = walFS.listStatus(editsDir, WALSplitter::isSequenceIdFile); return files != null ? files : new FileStatus[0]; } catch (FileNotFoundException e) { return new FileStatus[0]; @@ -676,16 +670,16 @@ private static long getMaxSequenceId(FileStatus[] files) { /** * Get the max sequence id which is stored in the region directory. -1 if none. */ - public static long getMaxRegionSequenceId(FileSystem fs, Path regionDir) throws IOException { - return getMaxSequenceId(getSequenceIdFiles(fs, regionDir)); + public static long getMaxRegionSequenceId(FileSystem walFS, Path regionDir) throws IOException { + return getMaxSequenceId(getSequenceIdFiles(walFS, regionDir)); } /** * Create a file with name as region's max sequence id */ - public static void writeRegionSequenceIdFile(FileSystem fs, Path regionDir, long newMaxSeqId) + public static void writeRegionSequenceIdFile(FileSystem walFS, Path regionDir, long newMaxSeqId) throws IOException { - FileStatus[] files = getSequenceIdFiles(fs, regionDir); + FileStatus[] files = getSequenceIdFiles(walFS, regionDir); long maxSeqId = getMaxSequenceId(files); if (maxSeqId > newMaxSeqId) { throw new IOException("The new max sequence id " + newMaxSeqId + @@ -696,7 +690,7 @@ public static void writeRegionSequenceIdFile(FileSystem fs, Path regionDir, long newMaxSeqId + SEQUENCE_ID_FILE_SUFFIX); if (newMaxSeqId != maxSeqId) { try { - if (!fs.createNewFile(newSeqIdFile) && !fs.exists(newSeqIdFile)) { + if (!walFS.createNewFile(newSeqIdFile) && !walFS.exists(newSeqIdFile)) { throw new IOException("Failed to create SeqId file:" + newSeqIdFile); } LOG.debug("Wrote file={}, newMaxSeqId={}, maxSeqId={}", newSeqIdFile, newMaxSeqId, @@ -708,7 +702,7 @@ public static void writeRegionSequenceIdFile(FileSystem fs, Path regionDir, long // remove old ones for (FileStatus status : files) { if (!newSeqIdFile.equals(status.getPath())) { - fs.delete(status.getPath(), false); + walFS.delete(status.getPath(), false); } } } @@ -735,7 +729,7 @@ protected Reader getReader(FileStatus file, boolean skipErrors, CancelableProgre } try { - FSUtils.getInstance(fs, conf).recoverFileLease(fs, path, conf, reporter); + FSUtils.getInstance(walFS, conf).recoverFileLease(walFS, path, conf, reporter); try { in = getReader(path, reporter); } catch (EOFException e) { @@ -802,7 +796,7 @@ static private Entry getNextLogLine(Reader in, Path path, boolean skipErrors) */ protected Writer createWriter(Path logfile) throws IOException { - return walFactory.createRecoveredEditsWriter(fs, logfile); + return walFactory.createRecoveredEditsWriter(walFS, logfile); } /** @@ -810,7 +804,7 @@ protected Writer createWriter(Path logfile) * @return new Reader instance, caller should close */ protected Reader getReader(Path curLogFile, CancelableProgressable reporter) throws IOException { - return walFactory.createReader(fs, curLogFile, reporter); + return walFactory.createReader(walFS, curLogFile, reporter); } /** @@ -1285,10 +1279,10 @@ public List finishWritingAndClose() throws IOException { } // delete the one with fewer wal entries - private void deleteOneWithFewerEntries(FileSystem rootFs, WriterAndPath wap, Path dst) + private void deleteOneWithFewerEntries(WriterAndPath wap, Path dst) throws IOException { long dstMinLogSeqNum = -1L; - try (WAL.Reader reader = walFactory.createReader(fs, dst)) { + try (WAL.Reader reader = walFactory.createReader(walFS, dst)) { WAL.Entry entry = reader.next(); if (entry != null) { dstMinLogSeqNum = entry.getKey().getSequenceId(); @@ -1300,15 +1294,15 @@ private void deleteOneWithFewerEntries(FileSystem rootFs, WriterAndPath wap, Pat if (wap.minLogSeqNum < dstMinLogSeqNum) { LOG.warn("Found existing old edits file. It could be the result of a previous failed" + " split attempt or we have duplicated wal entries. Deleting " + dst + ", length=" - + fs.getFileStatus(dst).getLen()); - if (!fs.delete(dst, false)) { + + walFS.getFileStatus(dst).getLen()); + if (!walFS.delete(dst, false)) { LOG.warn("Failed deleting of old {}", dst); throw new IOException("Failed deleting of old " + dst); } } else { LOG.warn("Found existing old edits file and we have less entries. Deleting " + wap.p - + ", length=" + rootFs.getFileStatus(wap.p).getLen()); - if (!rootFs.delete(wap.p, false)) { + + ", length=" + walFS.getFileStatus(wap.p).getLen()); + if (!walFS.delete(wap.p, false)) { LOG.warn("Failed deleting of {}", wap.p); throw new IOException("Failed deleting of " + wap.p); } @@ -1393,7 +1387,6 @@ boolean executeCloseTask(CompletionService completionService, Path closeWriter(String encodedRegionName, WriterAndPath wap, List thrown) throws IOException{ LOG.trace("Closing {}", wap.p); - FileSystem rootFs = FileSystem.get(conf); try { wap.w.close(); } catch (IOException ioe) { @@ -1408,7 +1401,7 @@ Path closeWriter(String encodedRegionName, WriterAndPath wap, } if (wap.editsWritten == 0) { // just remove the empty recovered.edits file - if (rootFs.exists(wap.p) && !rootFs.delete(wap.p, false)) { + if (walFS.exists(wap.p) && !walFS.delete(wap.p, false)) { LOG.warn("Failed deleting empty {}", wap.p); throw new IOException("Failed deleting empty " + wap.p); } @@ -1418,14 +1411,14 @@ Path closeWriter(String encodedRegionName, WriterAndPath wap, Path dst = getCompletedRecoveredEditsFilePath(wap.p, regionMaximumEditLogSeqNum.get(encodedRegionName)); try { - if (!dst.equals(wap.p) && rootFs.exists(dst)) { - deleteOneWithFewerEntries(rootFs, wap, dst); + if (!dst.equals(wap.p) && walFS.exists(dst)) { + deleteOneWithFewerEntries(wap, dst); } // Skip the unit tests which create a splitter that reads and // writes the data without touching disk. // TestHLogSplit#testThreading is an example. - if (rootFs.exists(wap.p)) { - if (!rootFs.rename(wap.p, dst)) { + if (walFS.exists(wap.p)) { + if (!walFS.rename(wap.p, dst)) { throw new IOException("Failed renaming " + wap.p + " to " + dst); } LOG.info("Rename {} to {}", wap.p, dst); @@ -1519,12 +1512,12 @@ WriterAndPath createWAP(byte[] region, Entry entry) throws IOException { if (regionedits == null) { return null; } - FileSystem rootFs = FileSystem.get(conf); - if (rootFs.exists(regionedits)) { + FileSystem walFs = FSUtils.getWALFileSystem(conf); + if (walFs.exists(regionedits)) { LOG.warn("Found old edits file. It could be the " + "result of a previous failed split attempt. Deleting " + regionedits + ", length=" - + rootFs.getFileStatus(regionedits).getLen()); - if (!rootFs.delete(regionedits, false)) { + + walFs.getFileStatus(regionedits).getLen()); + if (!walFs.delete(regionedits, false)) { LOG.warn("Failed delete of old {}", regionedits); } } diff --git a/hbase-server/src/main/resources/hbase-webapps/master/table.jsp b/hbase-server/src/main/resources/hbase-webapps/master/table.jsp index ea81cf601094..372e5ca35b83 100644 --- a/hbase-server/src/main/resources/hbase-webapps/master/table.jsp +++ b/hbase-server/src/main/resources/hbase-webapps/master/table.jsp @@ -23,7 +23,6 @@ import="java.util.ArrayList" import="java.util.Collection" import="java.util.Collections" - import="java.util.Comparator" import="java.util.HashMap" import="java.util.LinkedHashMap" import="java.util.List" @@ -82,11 +81,6 @@ MetaTableLocator metaTableLocator = new MetaTableLocator(); String fqtn = request.getParameter("name"); final String escaped_fqtn = StringEscapeUtils.escapeHtml4(fqtn); - String sortKey = request.getParameter("sort"); - String reverse = request.getParameter("reverse"); - final boolean reverseOrder = (reverse != null && reverse.equals("true")); - String showWholeKey = request.getParameter("showwhole"); - final boolean showWhole = (showWholeKey!=null && showWholeKey.equals("true")); Table table; String tableHeader; boolean withReplica = false; @@ -140,10 +134,10 @@ if ( fqtn != null ) { try { table = master.getConnection().getTable(TableName.valueOf(fqtn)); if (table.getTableDescriptor().getRegionReplication() > 1) { - tableHeader = "

    Table Regions

    "; + tableHeader = "

    Table Regions

    NameRegion ServerReadRequestsWriteRequestsStorefileSizeNum.StorefilesMemSizeLocalityStart KeyEnd KeyReplicaID
    "; withReplica = true; } else { - tableHeader = "

    Table Regions

    NameRegion ServerReadRequestsWriteRequestsStorefileSizeNum.StorefilesMemSizeLocalityStart KeyEnd KeyReplicaID
    "; + tableHeader = "

    Table Regions

    NameRegion ServerReadRequestsWriteRequestsStorefileSizeNum.StorefilesMemSizeLocalityStart KeyEnd Key
    "; } if ( !readOnly && action != null ) { %> @@ -202,6 +196,7 @@ if ( fqtn != null ) { if(fqtn.equals(TableName.META_TABLE_NAME.getNameAsString())) { %> <%= tableHeader %> + <% // NOTE: Presumes meta with one or more replicas for (int j = 0; j < numMetaReplicas; j++) { @@ -256,6 +251,7 @@ if ( fqtn != null ) { <% } %> <%} %> +
    NameRegion ServerReadRequestsWriteRequestsStorefileSizeNum.StorefilesMemSizeLocalityStart KeyEnd Key
    <%} else { Admin admin = master.getConnection().getAdmin(); @@ -444,22 +440,8 @@ if ( fqtn != null ) { if(regions != null && regions.size() > 0) { %>

    Table Regions

    -Sort As - -Ascending -ShowDetailName - -

    - - +
    + @@ -479,91 +461,12 @@ ShowDetailName <% } %> + + <% List> entryList = new ArrayList<>(regionsToLoad.entrySet()); - if (Objects.equals(sortKey, "regionname")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - RegionInfo regionInfo1 = entry1.getKey(); - RegionInfo regionInfo2 = entry2.getKey(); - String name1 = showWhole ? Bytes.toStringBinary(regionInfo1.getRegionName()) - : regionInfo1.getEncodedName(); - String name2 = showWhole ? Bytes.toStringBinary(regionInfo2.getRegionName()) - : regionInfo2.getEncodedName(); - return name1.compareTo(name2); - }); - } else if (Objects.equals(sortKey, "readrequest")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - return Long.compare(entry1.getValue().getReadRequestCount(), - entry2.getValue().getReadRequestCount()); - }); - } else if (Objects.equals(sortKey, "writerequest")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - return Long.compare(entry1.getValue().getWriteRequestCount(), - entry2.getValue().getWriteRequestCount()); - }); - } else if (Objects.equals(sortKey, "size")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - return Double.compare(entry1.getValue().getStoreFileSize().get(), - entry2.getValue().getStoreFileSize().get()); - }); - } else if (Objects.equals(sortKey, "filecount")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - return Integer.compare(entry1.getValue().getStoreCount(), - entry2.getValue().getStoreCount()); - }); - } else if (Objects.equals(sortKey, "memstore")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - return Double.compare(entry1.getValue().getMemStoreSize().get(), - entry2.getValue().getMemStoreSize().get()); - }); - } else if (Objects.equals(sortKey, "locality")) { - Collections.sort(entryList, (entry1, entry2) -> { - if (entry1 == null || entry1.getValue() == null) { - return -1; - } else if (entry2 == null || entry2.getValue() == null) { - return 1; - } - return Double.compare(entry1.getValue().getDataLocality(), - entry2.getValue().getDataLocality()); - }); - } - - if (reverseOrder) { - Collections.reverse(entryList); - } - numRegions = regions.size(); int numRegionsRendered = 0; // render all regions @@ -614,7 +517,7 @@ ShowDetailName numRegionsRendered++; %> - + <% if (urlRegionServer != null) { %> @@ -647,6 +550,7 @@ ShowDetailName <% } %> <% } %> +
    Name(<%= String.format("%,1d", regions.size())%>) Region Server
    <%= escapeXml(showWhole?Bytes.toStringBinary(regionInfo.getRegionName()):regionInfo.getEncodedName()) %><%= escapeXml(Bytes.toStringBinary(regionInfo.getRegionName())) %>
    <% if (numRegions > numRegionsRendered) { String allRegionsUrl = "?name=" + URLEncoder.encode(fqtn,"UTF-8") + "&numRegions=all"; @@ -659,11 +563,12 @@ ShowDetailName <% if (withReplica) { %> - +
    Region ServerRegion CountPrimary Region Count
    <% } else { %> -
    Region ServerRegion CountPrimary Region Count
    +
    Region ServerRegion Count
    + <% } %> @@ -684,6 +589,7 @@ if (withReplica) { %> <% } %> +
    Region ServerRegion Count
    <% } } catch(Exception ex) { @@ -811,37 +717,16 @@ Actions: <% } %> + + + diff --git a/hbase-server/src/main/resources/hbase-webapps/static/css/asc.gif b/hbase-server/src/main/resources/hbase-webapps/static/css/asc.gif new file mode 100644 index 000000000000..74157867f25a Binary files /dev/null and b/hbase-server/src/main/resources/hbase-webapps/static/css/asc.gif differ diff --git a/hbase-server/src/main/resources/hbase-webapps/static/css/bg.gif b/hbase-server/src/main/resources/hbase-webapps/static/css/bg.gif new file mode 100644 index 000000000000..fac668fcf42a Binary files /dev/null and b/hbase-server/src/main/resources/hbase-webapps/static/css/bg.gif differ diff --git a/hbase-server/src/main/resources/hbase-webapps/static/css/desc.gif b/hbase-server/src/main/resources/hbase-webapps/static/css/desc.gif new file mode 100644 index 000000000000..3b30b3c58eab Binary files /dev/null and b/hbase-server/src/main/resources/hbase-webapps/static/css/desc.gif differ diff --git a/hbase-server/src/main/resources/hbase-webapps/static/css/hbase.css b/hbase-server/src/main/resources/hbase-webapps/static/css/hbase.css index 03d8ff4f2666..04eb49625aa8 100644 --- a/hbase-server/src/main/resources/hbase-webapps/static/css/hbase.css +++ b/hbase-server/src/main/resources/hbase-webapps/static/css/hbase.css @@ -39,4 +39,18 @@ section { margin-bottom: 3em; } margin-top: 1.2em; } -/* Region Server page styling */ \ No newline at end of file +/* Region Server page styling */ + +/* sortable tables styling */ +table.tablesorter thead tr .header { + background-image: url(bg.gif); + background-repeat: no-repeat; + background-position: center right; + cursor: pointer; +} +table.tablesorter thead tr .headerSortUp { + background-image: url(asc.gif); +} +table.tablesorter thead tr .headerSortDown { + background-image: url(desc.gif); +} diff --git a/hbase-server/src/main/resources/hbase-webapps/static/js/jquery.tablesorter.min.js b/hbase-server/src/main/resources/hbase-webapps/static/js/jquery.tablesorter.min.js new file mode 100644 index 000000000000..ad84db6182d1 --- /dev/null +++ b/hbase-server/src/main/resources/hbase-webapps/static/js/jquery.tablesorter.min.js @@ -0,0 +1,4 @@ +/*! jQuery jquery.com | jquery.org/license */ +(function($){$.extend({tablesorter:new +function(){var parsers=[],widgets=[];this.defaults={cssHeader:"header",cssAsc:"headerSortUp",cssDesc:"headerSortDown",cssChildRow:"expand-child",sortInitialOrder:"asc",sortMultiSortKey:"shiftKey",sortForce:null,sortAppend:null,sortLocaleCompare:true,textExtraction:"simple",parsers:{},widgets:[],widgetZebra:{css:["even","odd"]},headers:{},widthFixed:false,cancelSelection:true,sortList:[],headerList:[],dateFormat:"us",decimal:'/\.|\,/g',onRenderHeader:null,selectorHeaders:'thead th',debug:false};function benchmark(s,d){log(s+","+(new Date().getTime()-d.getTime())+"ms");}this.benchmark=benchmark;function log(s){if(typeof console!="undefined"&&typeof console.debug!="undefined"){console.log(s);}else{alert(s);}}function buildParserCache(table,$headers){if(table.config.debug){var parsersDebug="";}if(table.tBodies.length==0)return;var rows=table.tBodies[0].rows;if(rows[0]){var list=[],cells=rows[0].cells,l=cells.length;for(var i=0;i1){arr=arr.concat(checkCellColSpan(table,headerArr,row++));}else{if(table.tHead.length==1||(cell.rowSpan>1||!r[row+1])){arr.push(cell);}}}return arr;};function checkHeaderMetadata(cell){if(($.metadata)&&($(cell).metadata().sorter===false)){return true;};return false;}function checkHeaderOptions(table,i){if((table.config.headers[i])&&(table.config.headers[i].sorter===false)){return true;};return false;}function checkHeaderOptionsSortingLocked(table,i){if((table.config.headers[i])&&(table.config.headers[i].lockedOrder))return table.config.headers[i].lockedOrder;return false;}function applyWidget(table){var c=table.config.widgets;var l=c.length;for(var i=0;i');$("tr:first td",table.tBodies[0]).each(function(){colgroup.append($('').css('width',$(this).width()));});$(table).prepend(colgroup);};}function updateHeaderSortCount(table,sortList){var c=table.config,l=sortList.length;for(var i=0;i b["+i+"]) ? 1 : 0));";};function makeSortTextDesc(i){return"((b["+i+"] < a["+i+"]) ? -1 : ((b["+i+"] > a["+i+"]) ? 1 : 0));";};function makeSortNumeric(i){return"a["+i+"]-b["+i+"];";};function makeSortNumericDesc(i){return"b["+i+"]-a["+i+"];";};function sortText(a,b){if(table.config.sortLocaleCompare)return a.localeCompare(b);return((ab)?1:0));};function sortTextDesc(a,b){if(table.config.sortLocaleCompare)return b.localeCompare(a);return((ba)?1:0));};function sortNumeric(a,b){return a-b;};function sortNumericDesc(a,b){return b-a;};function getCachedSortType(parsers,i){return parsers[i].type;};this.construct=function(settings){return this.each(function(){if(!this.tHead||!this.tBodies)return;var $this,$document,$headers,cache,config,shiftDown=0,sortOrder;this.config={};config=$.extend(this.config,$.tablesorter.defaults,settings);$this=$(this);$.data(this,"tablesorter",config);$headers=buildHeaders(this);this.config.parsers=buildParserCache(this,$headers);cache=buildCache(this);var sortCSS=[config.cssDesc,config.cssAsc];fixColumnWidth(this);$headers.click(function(e){var totalRows=($this[0].tBodies[0]&&$this[0].tBodies[0].rows.length)||0;if(!this.sortDisabled&&totalRows>0){$this.trigger("sortStart");var $cell=$(this);var i=this.column;this.order=this.count++%2;if(this.lockedOrder)this.order=this.lockedOrder;if(!e[config.sortMultiSortKey]){config.sortList=[];if(config.sortForce!=null){var a=config.sortForce;for(var j=0;j0){$this.trigger("sorton",[config.sortList]);}applyWidget(this);});};this.addParser=function(parser){var l=parsers.length,a=true;for(var i=0;i getProcedure(HBaseTestingUtility util, + Class> clazz, JsonParser parser) throws IOException { + JsonArray array = parser.parse(util.getAdmin().getProcedures()).getAsJsonArray(); + Iterator iterator = array.iterator(); + while (iterator.hasNext()) { + JsonElement element = iterator.next(); + JsonObject obj = element.getAsJsonObject(); + String className = obj.get("className").getAsString(); + if (className.equals(clazz.getName())) { + return Optional.of(obj); + } + } + return Optional.empty(); + } + + public static void waitUntilProcedureWaitingTimeout(HBaseTestingUtility util, + Class> clazz, long timeout) throws IOException { + JsonParser parser = new JsonParser(); + util.waitFor(timeout, + () -> getProcedure(util, clazz, parser) + .filter(o -> ProcedureState.WAITING_TIMEOUT.name().equals(o.get("state").getAsString())) + .isPresent()); + } + + public static void waitUntilProcedureTimeoutIncrease(HBaseTestingUtility util, + Class> clazz, int times) throws IOException, InterruptedException { + JsonParser parser = new JsonParser(); + long oldTimeout = 0; + int timeoutIncrements = 0; + for (;;) { + long timeout = getProcedure(util, clazz, parser).filter(o -> o.has("timeout")) + .map(o -> o.get("timeout").getAsLong()).orElse(-1L); + if (timeout > oldTimeout) { + LOG.info("Timeout incremented, was {}, now is {}, increments={}", timeout, oldTimeout, + timeoutIncrements); + oldTimeout = timeout; + timeoutIncrements++; + if (timeoutIncrements > times) { + break; + } + } + Thread.sleep(1000); + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestCheckTestClasses.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestCheckTestClasses.java index a20ef73535c8..d6b68fbcefa1 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestCheckTestClasses.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestCheckTestClasses.java @@ -20,10 +20,8 @@ import static org.junit.Assert.assertTrue; import java.util.List; - import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.MiscTests; -import org.apache.hadoop.hbase.testclassification.MediumTests; import org.junit.ClassRule; import org.junit.Test; import org.junit.experimental.categories.Category; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestMetaTableAccessor.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestMetaTableAccessor.java index eaed0bc8a8e2..0d21fb8d546c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestMetaTableAccessor.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestMetaTableAccessor.java @@ -109,7 +109,7 @@ public class TestMetaTableAccessor { @Test public void testIsMetaWhenAllHealthy() throws InterruptedException { HMaster m = UTIL.getMiniHBaseCluster().getMaster(); - assertTrue(m.waitUntilMetaOnline()); + assertTrue(m.waitForMetaOnline()); } @Test @@ -118,7 +118,7 @@ public void testIsMetaWhenMetaGoesOffline() throws InterruptedException { int index = UTIL.getMiniHBaseCluster().getServerWithMeta(); HRegionServer rsWithMeta = UTIL.getMiniHBaseCluster().getRegionServer(index); rsWithMeta.abort("TESTING"); - assertTrue(m.waitUntilMetaOnline()); + assertTrue(m.waitForMetaOnline()); } /** diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java index dfebd38a0a4c..2d32f9ecb420 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/TestHFileArchiving.java @@ -19,26 +19,33 @@ import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertTrue; import java.io.IOException; import java.util.ArrayList; import java.util.Collections; +import java.util.HashMap; import java.util.List; +import java.util.Map; +import java.util.Objects; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileStatus; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; import org.apache.hadoop.fs.PathFilter; -import org.apache.hadoop.hbase.*; +import org.apache.hadoop.hbase.ChoreService; import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.Stoppable; +import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; +import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.cleaner.HFileCleaner; -import org.apache.hadoop.hbase.regionserver.CompactingMemStore; import org.apache.hadoop.hbase.regionserver.ConstantSizeRegionSplitPolicy; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HRegionServer; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.MiscTests; import org.apache.hadoop.hbase.util.Bytes; @@ -177,10 +184,11 @@ public boolean accept(Path p) { /** * Test that the region directory is removed when we archive a region without store files, but * still has hidden files. - * @throws Exception + * @throws IOException throws an IOException if there's problem creating a table + * or if there's an issue with accessing FileSystem. */ @Test - public void testDeleteRegionWithNoStoreFiles() throws Exception { + public void testDeleteRegionWithNoStoreFiles() throws IOException { final TableName tableName = TableName.valueOf(name.getMethodName()); UTIL.createTable(tableName, TEST_FAM); @@ -209,7 +217,7 @@ public void testDeleteRegionWithNoStoreFiles() throws Exception { PathFilter nonHidden = new PathFilter() { @Override public boolean accept(Path file) { - return dirFilter.accept(file) && !file.getName().toString().startsWith("."); + return dirFilter.accept(file) && !file.getName().startsWith("."); } }; FileStatus[] storeDirs = FSUtils.listStatus(fs, regionDir, nonHidden); @@ -271,12 +279,14 @@ public void testArchiveOnTableDelete() throws Exception { assertArchiveFiles(fs, storeFiles, 30000); } - private void assertArchiveFiles(FileSystem fs, List storeFiles, long timeout) throws IOException { + private void assertArchiveFiles(FileSystem fs, List storeFiles, long timeout) + throws IOException { long end = System.currentTimeMillis() + timeout; Path archiveDir = HFileArchiveUtil.getArchivePath(UTIL.getConfiguration()); List archivedFiles = new ArrayList<>(); - // We have to ensure that the DeleteTableHandler is finished. HBaseAdmin.deleteXXX() can return before all files + // We have to ensure that the DeleteTableHandler is finished. HBaseAdmin.deleteXXX() + // can return before all files // are archived. We should fix HBASE-5487 and fix synchronous operations from admin. while (System.currentTimeMillis() < end) { archivedFiles = getAllFileNames(fs, archiveDir); @@ -304,10 +314,11 @@ private void assertArchiveFiles(FileSystem fs, List storeFiles, long tim /** * Test that the store files are archived when a column family is removed. - * @throws Exception + * @throws java.io.IOException if there's a problem creating a table. + * @throws java.lang.InterruptedException problem getting a RegionServer. */ @Test - public void testArchiveOnTableFamilyDelete() throws Exception { + public void testArchiveOnTableFamilyDelete() throws IOException, InterruptedException { final TableName tableName = TableName.valueOf(name.getMethodName()); UTIL.createTable(tableName, new byte[][] {TEST_FAM, Bytes.toBytes("fam2")}); @@ -374,11 +385,10 @@ public void testCleaningRace() throws Exception { Stoppable stoppable = new StoppableImplementation(); // The cleaner should be looping without long pauses to reproduce the race condition. - HFileCleaner cleaner = new HFileCleaner(1, stoppable, conf, fs, archiveDir); - assertFalse("cleaner should not be null", cleaner == null); + HFileCleaner cleaner = getHFileCleaner(stoppable, conf, fs, archiveDir); + assertNotNull("cleaner should not be null", cleaner); try { choreService.scheduleChore(cleaner); - // Keep creating/archiving new files while the cleaner is running in the other thread long startTime = System.currentTimeMillis(); for (long fid = 0; (System.currentTimeMillis() - startTime) < TEST_TIME; ++fid) { @@ -418,6 +428,16 @@ public void testCleaningRace() throws Exception { } } + // Avoid passing a null master to CleanerChore, see HBASE-21175 + private HFileCleaner getHFileCleaner(Stoppable stoppable, Configuration conf, + FileSystem fs, Path archiveDir) throws IOException { + Map params = new HashMap<>(); + params.put(HMaster.MASTER, UTIL.getMiniHBaseCluster().getMaster()); + HFileCleaner cleaner = new HFileCleaner(1, stoppable, conf, fs, archiveDir); + cleaner.init(params); + return Objects.requireNonNull(cleaner); + } + private void clearArchiveDirectory() throws IOException { UTIL.getTestFileSystem().delete( new Path(UTIL.getDefaultRootDirPath(), HConstants.HFILE_ARCHIVE_DIRECTORY), true); @@ -428,9 +448,9 @@ private void clearArchiveDirectory() throws IOException { * @param fs the file system to inspect * @param archiveDir the directory in which to look * @return a list of all files in the directory and sub-directories - * @throws IOException + * @throws java.io.IOException throws IOException in case FS is unavailable */ - private List getAllFileNames(final FileSystem fs, Path archiveDir) throws IOException { + private List getAllFileNames(final FileSystem fs, Path archiveDir) throws IOException { FileStatus[] files = FSUtils.listStatus(fs, archiveDir, new PathFilter() { @Override public boolean accept(Path p) { @@ -446,12 +466,16 @@ public boolean accept(Path p) { /** Recursively lookup all the file names under the file[] array **/ private List recurseOnFiles(FileSystem fs, FileStatus[] files, List fileNames) throws IOException { - if (files == null || files.length == 0) return fileNames; + if (files == null || files.length == 0) { + return fileNames; + } for (FileStatus file : files) { if (file.isDirectory()) { recurseOnFiles(fs, FSUtils.listStatus(fs, file.getPath(), null), fileNames); - } else fileNames.add(file.getPath().getName()); + } else { + fileNames.add(file.getPath().getName()); + } } return fileNames; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientAfterSplittingRegionTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientAfterSplittingRegionTestBase.java new file mode 100644 index 000000000000..d1108c0094e0 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientAfterSplittingRegionTestBase.java @@ -0,0 +1,81 @@ +/** + * 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.client; + +import static org.junit.Assert.assertEquals; + +import java.io.IOException; +import java.util.List; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.master.RegionState; +import org.apache.hadoop.hbase.master.assignment.RegionStates; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.Test; + +public class CloneSnapshotFromClientAfterSplittingRegionTestBase + extends CloneSnapshotFromClientTestBase { + + private void splitRegion(final RegionInfo regionInfo) throws IOException { + byte[][] splitPoints = Bytes.split(regionInfo.getStartKey(), regionInfo.getEndKey(), 1); + admin.split(regionInfo.getTable(), splitPoints[1]); + } + + @Test + public void testCloneSnapshotAfterSplittingRegion() throws IOException, InterruptedException { + // Turn off the CatalogJanitor + admin.catalogJanitorSwitch(false); + + try { + List regionInfos = admin.getRegions(tableName); + RegionReplicaUtil.removeNonDefaultRegions(regionInfos); + + // Split the first region + splitRegion(regionInfos.get(0)); + + // Take a snapshot + admin.snapshot(snapshotName2, tableName); + + // Clone the snapshot to another table + TableName clonedTableName = + TableName.valueOf(getValidMethodName() + "-" + System.currentTimeMillis()); + admin.cloneSnapshot(snapshotName2, clonedTableName); + SnapshotTestingUtils.waitForTableToBeOnline(TEST_UTIL, clonedTableName); + + RegionStates regionStates = + TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager().getRegionStates(); + + // The region count of the cloned table should be the same as the one of the original table + int openRegionCountOfOriginalTable = + regionStates.getRegionByStateOfTable(tableName).get(RegionState.State.OPEN).size(); + int openRegionCountOfClonedTable = + regionStates.getRegionByStateOfTable(clonedTableName).get(RegionState.State.OPEN).size(); + assertEquals(openRegionCountOfOriginalTable, openRegionCountOfClonedTable); + + int splitRegionCountOfOriginalTable = + regionStates.getRegionByStateOfTable(tableName).get(RegionState.State.SPLIT).size(); + int splitRegionCountOfClonedTable = + regionStates.getRegionByStateOfTable(clonedTableName).get(RegionState.State.SPLIT).size(); + assertEquals(splitRegionCountOfOriginalTable, splitRegionCountOfClonedTable); + + TEST_UTIL.deleteTable(clonedTableName); + } finally { + admin.catalogJanitorSwitch(true); + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientCloneLinksAfterDeleteTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientCloneLinksAfterDeleteTestBase.java new file mode 100644 index 000000000000..254aeac6a3bc --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientCloneLinksAfterDeleteTestBase.java @@ -0,0 +1,85 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.TableName; +import org.junit.Test; + +public class CloneSnapshotFromClientCloneLinksAfterDeleteTestBase + extends CloneSnapshotFromClientTestBase { + + /** + * Verify that tables created from the snapshot are still alive after source table deletion. + */ + @Test + public void testCloneLinksAfterDelete() throws IOException, InterruptedException { + // Clone a table from the first snapshot + final TableName clonedTableName = + TableName.valueOf(getValidMethodName() + "1-" + System.currentTimeMillis()); + admin.cloneSnapshot(snapshotName0, clonedTableName); + verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); + + // Take a snapshot of this cloned table. + admin.disableTable(clonedTableName); + admin.snapshot(snapshotName2, clonedTableName); + + // Clone the snapshot of the cloned table + final TableName clonedTableName2 = + TableName.valueOf(getValidMethodName() + "2-" + System.currentTimeMillis()); + admin.cloneSnapshot(snapshotName2, clonedTableName2); + verifyRowCount(TEST_UTIL, clonedTableName2, snapshot0Rows); + admin.disableTable(clonedTableName2); + + // Remove the original table + TEST_UTIL.deleteTable(tableName); + waitCleanerRun(); + + // Verify the first cloned table + admin.enableTable(clonedTableName); + verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); + + // Verify the second cloned table + admin.enableTable(clonedTableName2); + verifyRowCount(TEST_UTIL, clonedTableName2, snapshot0Rows); + admin.disableTable(clonedTableName2); + + // Delete the first cloned table + TEST_UTIL.deleteTable(clonedTableName); + waitCleanerRun(); + + // Verify the second cloned table + admin.enableTable(clonedTableName2); + verifyRowCount(TEST_UTIL, clonedTableName2, snapshot0Rows); + + // Clone a new table from cloned + final TableName clonedTableName3 = + TableName.valueOf(getValidMethodName() + "3-" + System.currentTimeMillis()); + admin.cloneSnapshot(snapshotName2, clonedTableName3); + verifyRowCount(TEST_UTIL, clonedTableName3, snapshot0Rows); + + // Delete the cloned tables + TEST_UTIL.deleteTable(clonedTableName2); + TEST_UTIL.deleteTable(clonedTableName3); + admin.deleteSnapshot(snapshotName2); + } + + private void waitCleanerRun() throws InterruptedException { + TEST_UTIL.getMiniHBaseCluster().getMaster().getHFileCleaner().choreForTesting(); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientErrorTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientErrorTestBase.java new file mode 100644 index 000000000000..04df8e44b7ac --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientErrorTestBase.java @@ -0,0 +1,41 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.NamespaceNotFoundException; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.snapshot.SnapshotDoesNotExistException; +import org.junit.Test; + +public class CloneSnapshotFromClientErrorTestBase extends CloneSnapshotFromClientTestBase { + + @Test(expected = SnapshotDoesNotExistException.class) + public void testCloneNonExistentSnapshot() throws IOException, InterruptedException { + String snapshotName = "random-snapshot-" + System.currentTimeMillis(); + final TableName tableName = + TableName.valueOf(getValidMethodName() + "-" + System.currentTimeMillis()); + admin.cloneSnapshot(snapshotName, tableName); + } + + @Test(expected = NamespaceNotFoundException.class) + public void testCloneOnMissingNamespace() throws IOException, InterruptedException { + final TableName clonedTableName = TableName.valueOf("unknownNS:" + getValidMethodName()); + admin.cloneSnapshot(snapshotName1, clonedTableName); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientNormalTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientNormalTestBase.java new file mode 100644 index 000000000000..3e26076e345c --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientNormalTestBase.java @@ -0,0 +1,61 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.NamespaceDescriptor; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.junit.Test; + +public class CloneSnapshotFromClientNormalTestBase extends CloneSnapshotFromClientTestBase { + + @Test + public void testCloneSnapshot() throws IOException, InterruptedException { + TableName clonedTableName = + TableName.valueOf(getValidMethodName() + "-" + System.currentTimeMillis()); + testCloneSnapshot(clonedTableName, snapshotName0, snapshot0Rows); + testCloneSnapshot(clonedTableName, snapshotName1, snapshot1Rows); + testCloneSnapshot(clonedTableName, emptySnapshot, 0); + } + + private void testCloneSnapshot(TableName tableName, byte[] snapshotName, int snapshotRows) + throws IOException, InterruptedException { + // create a new table from snapshot + admin.cloneSnapshot(snapshotName, tableName); + verifyRowCount(TEST_UTIL, tableName, snapshotRows); + + verifyReplicasCameOnline(tableName); + TEST_UTIL.deleteTable(tableName); + } + + private void verifyReplicasCameOnline(TableName tableName) throws IOException { + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + } + + @Test + public void testCloneSnapshotCrossNamespace() throws IOException, InterruptedException { + String nsName = getValidMethodName() + "_ns_" + System.currentTimeMillis(); + admin.createNamespace(NamespaceDescriptor.create(nsName).build()); + final TableName clonedTableName = + TableName.valueOf(nsName, getValidMethodName() + "-" + System.currentTimeMillis()); + testCloneSnapshot(clonedTableName, snapshotName0, snapshot0Rows); + testCloneSnapshot(clonedTableName, snapshotName1, snapshot1Rows); + testCloneSnapshot(clonedTableName, emptySnapshot, 0); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientTestBase.java new file mode 100644 index 000000000000..c74ec1dcd01e --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/CloneSnapshotFromClientTestBase.java @@ -0,0 +1,161 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.rules.TestName; + +/** + * Base class for testing clone snapsot + */ +public class CloneSnapshotFromClientTestBase { + + protected final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); + + protected final byte[] FAMILY = Bytes.toBytes("cf"); + + protected byte[] emptySnapshot; + protected byte[] snapshotName0; + protected byte[] snapshotName1; + protected byte[] snapshotName2; + protected TableName tableName; + protected int snapshot0Rows; + protected int snapshot1Rows; + protected Admin admin; + + @Rule + public TestName name = new TestName(); + + protected static void setupConfiguration() { + TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); + TEST_UTIL.getConfiguration().setInt("hbase.hstore.compactionThreshold", 10); + TEST_UTIL.getConfiguration().setInt("hbase.regionserver.msginterval", 100); + TEST_UTIL.getConfiguration().setInt("hbase.client.pause", 250); + TEST_UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 6); + TEST_UTIL.getConfiguration().setBoolean("hbase.master.enabletable.roundrobin", true); + } + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + setupConfiguration(); + TEST_UTIL.startMiniCluster(3); + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + TEST_UTIL.shutdownMiniCluster(); + } + + protected final String getValidMethodName() { + return name.getMethodName().replaceAll("[^0-9A-Za-z_]", "_"); + } + + /** + * Initialize the tests with a table filled with some data and two snapshots (snapshotName0, + * snapshotName1) of different states. The tableName, snapshotNames and the number of rows in the + * snapshot are initialized. + */ + @Before + public void setup() throws Exception { + this.admin = TEST_UTIL.getAdmin(); + + long tid = System.currentTimeMillis(); + tableName = TableName.valueOf(getValidMethodName() + tid); + emptySnapshot = Bytes.toBytes("emptySnaptb-" + tid); + snapshotName0 = Bytes.toBytes("snaptb0-" + tid); + snapshotName1 = Bytes.toBytes("snaptb1-" + tid); + snapshotName2 = Bytes.toBytes("snaptb2-" + tid); + + createTableAndSnapshots(); + } + + protected void createTable() throws IOException, InterruptedException { + SnapshotTestingUtils.createTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + protected int numRowsToLoad() { + return 500; + } + + protected int countRows(Table table) throws IOException { + return TEST_UTIL.countRows(table); + } + + private void createTableAndSnapshots() throws Exception { + // create Table and disable it + createTable(); + admin.disableTable(tableName); + + // take an empty snapshot + admin.snapshot(emptySnapshot, tableName); + + // enable table and insert data + admin.enableTable(tableName); + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, numRowsToLoad(), FAMILY); + try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { + snapshot0Rows = countRows(table); + } + admin.disableTable(tableName); + + // take a snapshot + admin.snapshot(snapshotName0, tableName); + + // enable table and insert more data + admin.enableTable(tableName); + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, numRowsToLoad(), FAMILY); + try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { + snapshot1Rows = countRows(table); + } + admin.disableTable(tableName); + + // take a snapshot of the updated table + admin.snapshot(snapshotName1, tableName); + + // re-enable table + admin.enableTable(tableName); + } + + protected int getNumReplicas() { + return 1; + } + + protected void verifyRowCount(final HBaseTestingUtility util, final TableName tableName, + long expectedRows) throws IOException { + SnapshotTestingUtils.verifyRowCount(util, tableName, expectedRows); + } + + @After + public void tearDown() throws Exception { + if (admin.tableExists(tableName)) { + TEST_UTIL.deleteTable(tableName); + } + SnapshotTestingUtils.deleteAllSnapshots(admin); + SnapshotTestingUtils.deleteArchiveDirectory(TEST_UTIL); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientAfterSplittingRegionsTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientAfterSplittingRegionsTestBase.java new file mode 100644 index 000000000000..59f0fd41087c --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientAfterSplittingRegionsTestBase.java @@ -0,0 +1,52 @@ +/** + * 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.client; + +import java.io.IOException; +import java.util.List; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.junit.Test; + +public class RestoreSnapshotFromClientAfterSplittingRegionsTestBase + extends RestoreSnapshotFromClientTestBase { + + @Test + public void testRestoreSnapshotAfterSplittingRegions() throws IOException, InterruptedException { + List regionInfos = admin.getRegions(tableName); + RegionReplicaUtil.removeNonDefaultRegions(regionInfos); + + // Split the first region + splitRegion(regionInfos.get(0)); + + // Take a snapshot + admin.snapshot(snapshotName1, tableName); + + // Load more data + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); + + // Split the second region + splitRegion(regionInfos.get(1)); + + // Restore the snapshot + admin.disableTable(tableName); + admin.restoreSnapshot(snapshotName1); + admin.enableTable(tableName); + + verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientAfterTruncateTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientAfterTruncateTestBase.java new file mode 100644 index 000000000000..11fd6f196c1f --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientAfterTruncateTestBase.java @@ -0,0 +1,48 @@ +/** + * 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.client; + +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.junit.Test; + +public class RestoreSnapshotFromClientAfterTruncateTestBase + extends RestoreSnapshotFromClientTestBase { + + @Test + public void testRestoreSnapshotAfterTruncate() throws Exception { + TableName tableName = TableName.valueOf(getValidMethodName()); + SnapshotTestingUtils.createTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); + int numOfRows = 0; + + try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { + numOfRows = countRows(table); + } + // take snapshot + admin.snapshot("snap", tableName); + admin.disableTable(tableName); + admin.truncateTable(tableName, false); + admin.disableTable(tableName); + admin.restoreSnapshot("snap"); + + admin.enableTable(tableName); + verifyRowCount(TEST_UTIL, tableName, numOfRows); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientCloneTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientCloneTestBase.java new file mode 100644 index 000000000000..07625f9638f7 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientCloneTestBase.java @@ -0,0 +1,65 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.junit.Test; + +public class RestoreSnapshotFromClientCloneTestBase extends RestoreSnapshotFromClientTestBase { + + @Test + public void testCloneSnapshotOfCloned() throws IOException, InterruptedException { + TableName clonedTableName = + TableName.valueOf(getValidMethodName() + "-" + System.currentTimeMillis()); + admin.cloneSnapshot(snapshotName0, clonedTableName); + verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(clonedTableName, admin, getNumReplicas()); + admin.disableTable(clonedTableName); + admin.snapshot(snapshotName2, clonedTableName); + TEST_UTIL.deleteTable(clonedTableName); + waitCleanerRun(); + + admin.cloneSnapshot(snapshotName2, clonedTableName); + verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(clonedTableName, admin, getNumReplicas()); + TEST_UTIL.deleteTable(clonedTableName); + } + + @Test + public void testCloneAndRestoreSnapshot() throws IOException, InterruptedException { + TEST_UTIL.deleteTable(tableName); + waitCleanerRun(); + + admin.cloneSnapshot(snapshotName0, tableName); + verifyRowCount(TEST_UTIL, tableName, snapshot0Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + waitCleanerRun(); + + admin.disableTable(tableName); + admin.restoreSnapshot(snapshotName0); + admin.enableTable(tableName); + verifyRowCount(TEST_UTIL, tableName, snapshot0Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + } + + private void waitCleanerRun() throws InterruptedException { + TEST_UTIL.getMiniHBaseCluster().getMaster().getHFileCleaner().choreForTesting(); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientGetCompactionStateTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientGetCompactionStateTestBase.java new file mode 100644 index 000000000000..03c908fd0680 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientGetCompactionStateTestBase.java @@ -0,0 +1,44 @@ +/** + * 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.client; + +import static org.junit.Assert.assertEquals; + +import java.io.IOException; +import org.junit.Test; + +public class RestoreSnapshotFromClientGetCompactionStateTestBase + extends RestoreSnapshotFromClientTestBase { + + @Test + public void testGetCompactionStateAfterRestoringSnapshot() + throws IOException, InterruptedException { + // Take a snapshot + admin.snapshot(snapshotName1, tableName); + + // Restore the snapshot + admin.disableTable(tableName); + admin.restoreSnapshot(snapshotName1); + + // Get the compaction state of the restored table + CompactionState compactionState = admin.getCompactionState(tableName); + + // The compactionState should be NONE because the table is disabled + assertEquals(CompactionState.NONE, compactionState); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientSchemaChangeTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientSchemaChangeTestBase.java new file mode 100644 index 000000000000..7f88f6ed3cc3 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientSchemaChangeTestBase.java @@ -0,0 +1,105 @@ +/** + * 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.client; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.fail; + +import java.io.IOException; +import java.util.HashSet; +import java.util.Set; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.master.MasterFileSystem; +import org.apache.hadoop.hbase.regionserver.NoSuchColumnFamilyException; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.FSUtils; +import org.junit.Test; + +public class RestoreSnapshotFromClientSchemaChangeTestBase + extends RestoreSnapshotFromClientTestBase { + + private Set getFamiliesFromFS(final TableName tableName) throws IOException { + MasterFileSystem mfs = TEST_UTIL.getMiniHBaseCluster().getMaster().getMasterFileSystem(); + Set families = new HashSet<>(); + Path tableDir = FSUtils.getTableDir(mfs.getRootDir(), tableName); + for (Path regionDir : FSUtils.getRegionDirs(mfs.getFileSystem(), tableDir)) { + for (Path familyDir : FSUtils.getFamilyDirs(mfs.getFileSystem(), regionDir)) { + families.add(familyDir.getName()); + } + } + return families; + } + + protected ColumnFamilyDescriptor getTestRestoreSchemaChangeHCD() { + return ColumnFamilyDescriptorBuilder.of(TEST_FAMILY2); + } + + @Test + public void testRestoreSchemaChange() throws Exception { + Table table = TEST_UTIL.getConnection().getTable(tableName); + + // Add one column family and put some data in it + admin.disableTable(tableName); + admin.addColumnFamily(tableName, getTestRestoreSchemaChangeHCD()); + admin.enableTable(tableName); + assertEquals(2, table.getDescriptor().getColumnFamilyCount()); + TableDescriptor htd = admin.getDescriptor(tableName); + assertEquals(2, htd.getColumnFamilyCount()); + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, TEST_FAMILY2); + long snapshot2Rows = snapshot1Rows + 500L; + assertEquals(snapshot2Rows, countRows(table)); + assertEquals(500, countRows(table, TEST_FAMILY2)); + Set fsFamilies = getFamiliesFromFS(tableName); + assertEquals(2, fsFamilies.size()); + + // Take a snapshot + admin.disableTable(tableName); + admin.snapshot(snapshotName2, tableName); + + // Restore the snapshot (without the cf) + admin.restoreSnapshot(snapshotName0); + admin.enableTable(tableName); + assertEquals(1, table.getDescriptor().getColumnFamilyCount()); + try { + countRows(table, TEST_FAMILY2); + fail("family '" + Bytes.toString(TEST_FAMILY2) + "' should not exists"); + } catch (NoSuchColumnFamilyException e) { + // expected + } + assertEquals(snapshot0Rows, countRows(table)); + htd = admin.getDescriptor(tableName); + assertEquals(1, htd.getColumnFamilyCount()); + fsFamilies = getFamiliesFromFS(tableName); + assertEquals(1, fsFamilies.size()); + + // Restore back the snapshot (with the cf) + admin.disableTable(tableName); + admin.restoreSnapshot(snapshotName2); + admin.enableTable(tableName); + htd = admin.getDescriptor(tableName); + assertEquals(2, htd.getColumnFamilyCount()); + assertEquals(2, table.getDescriptor().getColumnFamilyCount()); + assertEquals(500, countRows(table, TEST_FAMILY2)); + assertEquals(snapshot2Rows, countRows(table)); + fsFamilies = getFamiliesFromFS(tableName); + assertEquals(2, fsFamilies.size()); + table.close(); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientSimpleTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientSimpleTestBase.java new file mode 100644 index 000000000000..f4f2698a948a --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientSimpleTestBase.java @@ -0,0 +1,80 @@ +/** + * 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.client; + +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.fail; + +import java.io.IOException; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.snapshot.CorruptedSnapshotException; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.Test; + +public class RestoreSnapshotFromClientSimpleTestBase extends RestoreSnapshotFromClientTestBase { + + @Test + public void testRestoreSnapshot() throws IOException { + verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); + admin.disableTable(tableName); + admin.snapshot(snapshotName1, tableName); + // Restore from snapshot-0 + admin.restoreSnapshot(snapshotName0); + admin.enableTable(tableName); + verifyRowCount(TEST_UTIL, tableName, snapshot0Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + + // Restore from emptySnapshot + admin.disableTable(tableName); + admin.restoreSnapshot(emptySnapshot); + admin.enableTable(tableName); + verifyRowCount(TEST_UTIL, tableName, 0); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + + // Restore from snapshot-1 + admin.disableTable(tableName); + admin.restoreSnapshot(snapshotName1); + admin.enableTable(tableName); + verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + + // Restore from snapshot-1 + TEST_UTIL.deleteTable(tableName); + admin.restoreSnapshot(snapshotName1); + verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); + SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); + } + + @Test + public void testCorruptedSnapshot() throws IOException, InterruptedException { + SnapshotTestingUtils.corruptSnapshot(TEST_UTIL, Bytes.toString(snapshotName0)); + TableName cloneName = + TableName.valueOf(getValidMethodName() + "-" + System.currentTimeMillis()); + try { + admin.cloneSnapshot(snapshotName0, cloneName); + fail("Expected CorruptedSnapshotException, got succeeded cloneSnapshot()"); + } catch (CorruptedSnapshotException e) { + // Got the expected corruption exception. + // check for no references of the cloned table. + assertFalse(admin.tableExists(cloneName)); + } catch (Exception e) { + fail("Expected CorruptedSnapshotException got: " + e); + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientTestBase.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientTestBase.java new file mode 100644 index 000000000000..047640fe7d78 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/RestoreSnapshotFromClientTestBase.java @@ -0,0 +1,150 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.After; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.rules.TestName; + +/** + * Base class for testing restore snapshot + */ +public class RestoreSnapshotFromClientTestBase { + protected final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); + + protected final byte[] FAMILY = Bytes.toBytes("cf"); + protected final byte[] TEST_FAMILY2 = Bytes.toBytes("cf2"); + + protected TableName tableName; + protected byte[] emptySnapshot; + protected byte[] snapshotName0; + protected byte[] snapshotName1; + protected byte[] snapshotName2; + protected int snapshot0Rows; + protected int snapshot1Rows; + protected Admin admin; + + @Rule + public TestName name = new TestName(); + + @BeforeClass + public static void setupCluster() throws Exception { + setupConf(TEST_UTIL.getConfiguration()); + TEST_UTIL.startMiniCluster(3); + } + + protected static void setupConf(Configuration conf) { + TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); + TEST_UTIL.getConfiguration().setInt("hbase.hstore.compactionThreshold", 10); + TEST_UTIL.getConfiguration().setInt("hbase.regionserver.msginterval", 100); + TEST_UTIL.getConfiguration().setInt("hbase.client.pause", 250); + TEST_UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 6); + TEST_UTIL.getConfiguration().setBoolean("hbase.master.enabletable.roundrobin", true); + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + TEST_UTIL.shutdownMiniCluster(); + } + + /** + * Initialize the tests with a table filled with some data and two snapshots (snapshotName0, + * snapshotName1) of different states. The tableName, snapshotNames and the number of rows in the + * snapshot are initialized. + */ + @Before + public void setup() throws Exception { + this.admin = TEST_UTIL.getAdmin(); + + long tid = System.currentTimeMillis(); + tableName = TableName.valueOf(getValidMethodName() + "-" + tid); + emptySnapshot = Bytes.toBytes("emptySnaptb-" + tid); + snapshotName0 = Bytes.toBytes("snaptb0-" + tid); + snapshotName1 = Bytes.toBytes("snaptb1-" + tid); + snapshotName2 = Bytes.toBytes("snaptb2-" + tid); + + // create Table and disable it + createTable(); + admin.disableTable(tableName); + + // take an empty snapshot + admin.snapshot(emptySnapshot, tableName); + + // enable table and insert data + admin.enableTable(tableName); + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); + try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { + snapshot0Rows = countRows(table); + } + admin.disableTable(tableName); + + // take a snapshot + admin.snapshot(snapshotName0, tableName); + + // enable table and insert more data + admin.enableTable(tableName); + SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); + try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { + snapshot1Rows = countRows(table); + } + } + + protected void createTable() throws Exception { + SnapshotTestingUtils.createTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + @After + public void tearDown() throws Exception { + TEST_UTIL.deleteTable(tableName); + SnapshotTestingUtils.deleteAllSnapshots(TEST_UTIL.getAdmin()); + SnapshotTestingUtils.deleteArchiveDirectory(TEST_UTIL); + } + + protected int getNumReplicas() { + return 1; + } + + protected int countRows(Table table, byte[]... families) throws IOException { + return TEST_UTIL.countRows(table, families); + } + + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + SnapshotTestingUtils.verifyRowCount(util, tableName, expectedRows); + } + + protected final void splitRegion(RegionInfo regionInfo) throws IOException { + byte[][] splitPoints = Bytes.split(regionInfo.getStartKey(), regionInfo.getEndKey(), 1); + admin.split(regionInfo.getTable(), splitPoints[1]); + } + + protected final String getValidMethodName() { + return name.getMethodName().replaceAll("[^0-9A-Za-z_]", "_"); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java index 6fc59be29552..4ab1a8fbee0b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAdmin2.java @@ -48,10 +48,12 @@ import org.apache.hadoop.hbase.UnknownRegionException; import org.apache.hadoop.hbase.ZooKeeperConnectionException; import org.apache.hadoop.hbase.constraint.ConstraintException; +import org.apache.hadoop.hbase.ipc.HBaseRpcController; import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.assignment.AssignmentManager; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HRegionServer; +import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.testclassification.ClientTests; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.util.Bytes; @@ -59,6 +61,7 @@ import org.apache.hadoop.hbase.wal.AbstractFSWALProvider; import org.junit.After; import org.junit.AfterClass; +import org.junit.Assert; import org.junit.Before; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -754,4 +757,40 @@ public void testDecommissionRegionServers() throws Exception { } } } + + /** + * TestCase for HBASE-21355 + */ + @Test + public void testGetRegionInfo() throws Exception { + final TableName tableName = TableName.valueOf(name.getMethodName()); + Table table = TEST_UTIL.createTable(tableName, Bytes.toBytes("f")); + for (int i = 0; i < 100; i++) { + table.put(new Put(Bytes.toBytes(i)).addColumn(Bytes.toBytes("f"), Bytes.toBytes("q"), + Bytes.toBytes(i))); + } + admin.flush(tableName); + + HRegionServer rs = TEST_UTIL.getRSForFirstRegionInTable(table.getName()); + List regions = rs.getRegions(tableName); + Assert.assertEquals(1, regions.size()); + + HRegion region = regions.get(0); + byte[] regionName = region.getRegionInfo().getRegionName(); + HStore store = region.getStore(Bytes.toBytes("f")); + long expectedStoreFilesSize = store.getStorefilesSize(); + Assert.assertNotNull(store); + Assert.assertEquals(expectedStoreFilesSize, store.getSize()); + + ClusterConnection conn = ((ClusterConnection) admin.getConnection()); + HBaseRpcController controller = conn.getRpcControllerFactory().newController(); + for (int i = 0; i < 10; i++) { + RegionInfo ri = + ProtobufUtil.getRegionInfo(controller, conn.getAdmin(rs.getServerName()), regionName); + Assert.assertEquals(region.getRegionInfo(), ri); + + // Make sure that the store size is still the actual file system's store size. + Assert.assertEquals(expectedStoreFilesSize, store.getSize()); + } + } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClient.java deleted file mode 100644 index 157b18f2d261..000000000000 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClient.java +++ /dev/null @@ -1,329 +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.client; - -import static org.junit.Assert.assertEquals; - -import java.io.IOException; -import java.util.List; - -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.NamespaceDescriptor; -import org.apache.hadoop.hbase.NamespaceNotFoundException; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.master.RegionState; -import org.apache.hadoop.hbase.master.assignment.RegionStates; -import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; -import org.apache.hadoop.hbase.snapshot.SnapshotDoesNotExistException; -import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; -import org.apache.hadoop.hbase.testclassification.ClientTests; -import org.apache.hadoop.hbase.testclassification.LargeTests; -import org.apache.hadoop.hbase.util.Bytes; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -/** - * Test clone snapshots from the client - */ -@Category({LargeTests.class, ClientTests.class}) -public class TestCloneSnapshotFromClient { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCloneSnapshotFromClient.class); - - private static final Logger LOG = LoggerFactory.getLogger(TestCloneSnapshotFromClient.class); - - protected final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); - - protected final byte[] FAMILY = Bytes.toBytes("cf"); - - protected byte[] emptySnapshot; - protected byte[] snapshotName0; - protected byte[] snapshotName1; - protected byte[] snapshotName2; - protected TableName tableName; - protected int snapshot0Rows; - protected int snapshot1Rows; - protected Admin admin; - - @Rule - public TestName name = new TestName(); - - protected static void setupConfiguration() { - TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); - TEST_UTIL.getConfiguration().setInt("hbase.hstore.compactionThreshold", 10); - TEST_UTIL.getConfiguration().setInt("hbase.regionserver.msginterval", 100); - TEST_UTIL.getConfiguration().setInt("hbase.client.pause", 250); - TEST_UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 6); - TEST_UTIL.getConfiguration().setBoolean( - "hbase.master.enabletable.roundrobin", true); - } - - @BeforeClass - public static void setUpBeforeClass() throws Exception { - setupConfiguration(); - TEST_UTIL.startMiniCluster(3); - } - - @AfterClass - public static void tearDownAfterClass() throws Exception { - TEST_UTIL.shutdownMiniCluster(); - } - - /** - * Initialize the tests with a table filled with some data - * and two snapshots (snapshotName0, snapshotName1) of different states. - * The tableName, snapshotNames and the number of rows in the snapshot are initialized. - */ - @Before - public void setup() throws Exception { - this.admin = TEST_UTIL.getAdmin(); - - long tid = System.currentTimeMillis(); - tableName = TableName.valueOf(name.getMethodName() + tid); - emptySnapshot = Bytes.toBytes("emptySnaptb-" + tid); - snapshotName0 = Bytes.toBytes("snaptb0-" + tid); - snapshotName1 = Bytes.toBytes("snaptb1-" + tid); - snapshotName2 = Bytes.toBytes("snaptb2-" + tid); - - createTableAndSnapshots(); - } - - protected void createTableAndSnapshots() throws Exception { - // create Table and disable it - SnapshotTestingUtils.createTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); - admin.disableTable(tableName); - - // take an empty snapshot - admin.snapshot(emptySnapshot, tableName); - - // enable table and insert data - admin.enableTable(tableName); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); - try (Table table = TEST_UTIL.getConnection().getTable(tableName)){ - snapshot0Rows = TEST_UTIL.countRows(table); - } - admin.disableTable(tableName); - - // take a snapshot - admin.snapshot(snapshotName0, tableName); - - // enable table and insert more data - admin.enableTable(tableName); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); - try (Table table = TEST_UTIL.getConnection().getTable(tableName)){ - snapshot1Rows = TEST_UTIL.countRows(table); - } - admin.disableTable(tableName); - - // take a snapshot of the updated table - admin.snapshot(snapshotName1, tableName); - - // re-enable table - admin.enableTable(tableName); - } - - protected int getNumReplicas() { - return 1; - } - - @After - public void tearDown() throws Exception { - if (admin.tableExists(tableName)) { - TEST_UTIL.deleteTable(tableName); - } - SnapshotTestingUtils.deleteAllSnapshots(admin); - SnapshotTestingUtils.deleteArchiveDirectory(TEST_UTIL); - } - - @Test(expected=SnapshotDoesNotExistException.class) - public void testCloneNonExistentSnapshot() throws IOException, InterruptedException { - String snapshotName = "random-snapshot-" + System.currentTimeMillis(); - final TableName tableName = TableName.valueOf(name.getMethodName() + "-" - + System.currentTimeMillis()); - admin.cloneSnapshot(snapshotName, tableName); - } - - @Test(expected = NamespaceNotFoundException.class) - public void testCloneOnMissingNamespace() throws IOException, InterruptedException { - final TableName clonedTableName = TableName.valueOf("unknownNS:" + name.getMethodName()); - admin.cloneSnapshot(snapshotName1, clonedTableName); - } - - @Test - public void testCloneSnapshot() throws IOException, InterruptedException { - final TableName clonedTableName = TableName.valueOf(name.getMethodName() + "-" - + System.currentTimeMillis()); - testCloneSnapshot(clonedTableName, snapshotName0, snapshot0Rows); - testCloneSnapshot(clonedTableName, snapshotName1, snapshot1Rows); - testCloneSnapshot(clonedTableName, emptySnapshot, 0); - } - - private void testCloneSnapshot(final TableName tableName, final byte[] snapshotName, - int snapshotRows) throws IOException, InterruptedException { - // create a new table from snapshot - admin.cloneSnapshot(snapshotName, tableName); - verifyRowCount(TEST_UTIL, tableName, snapshotRows); - - verifyReplicasCameOnline(tableName); - TEST_UTIL.deleteTable(tableName); - } - - protected void verifyReplicasCameOnline(TableName tableName) throws IOException { - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - } - - @Test - public void testCloneSnapshotCrossNamespace() throws IOException, InterruptedException { - String nsName = "testCloneSnapshotCrossNamespace"; - admin.createNamespace(NamespaceDescriptor.create(nsName).build()); - final TableName clonedTableName = TableName.valueOf(nsName, name.getMethodName() - + "-" + System.currentTimeMillis()); - testCloneSnapshot(clonedTableName, snapshotName0, snapshot0Rows); - testCloneSnapshot(clonedTableName, snapshotName1, snapshot1Rows); - testCloneSnapshot(clonedTableName, emptySnapshot, 0); - } - - /** - * Verify that tables created from the snapshot are still alive after source table deletion. - */ - @Test - public void testCloneLinksAfterDelete() throws IOException, InterruptedException { - // Clone a table from the first snapshot - final TableName clonedTableName = TableName.valueOf(name.getMethodName() + "1-" - + System.currentTimeMillis()); - admin.cloneSnapshot(snapshotName0, clonedTableName); - verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); - - // Take a snapshot of this cloned table. - admin.disableTable(clonedTableName); - admin.snapshot(snapshotName2, clonedTableName); - - // Clone the snapshot of the cloned table - final TableName clonedTableName2 = TableName.valueOf(name.getMethodName() + "2-" - + System.currentTimeMillis()); - admin.cloneSnapshot(snapshotName2, clonedTableName2); - verifyRowCount(TEST_UTIL, clonedTableName2, snapshot0Rows); - admin.disableTable(clonedTableName2); - - // Remove the original table - TEST_UTIL.deleteTable(tableName); - waitCleanerRun(); - - // Verify the first cloned table - admin.enableTable(clonedTableName); - verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); - - // Verify the second cloned table - admin.enableTable(clonedTableName2); - verifyRowCount(TEST_UTIL, clonedTableName2, snapshot0Rows); - admin.disableTable(clonedTableName2); - - // Delete the first cloned table - TEST_UTIL.deleteTable(clonedTableName); - waitCleanerRun(); - - // Verify the second cloned table - admin.enableTable(clonedTableName2); - verifyRowCount(TEST_UTIL, clonedTableName2, snapshot0Rows); - - // Clone a new table from cloned - final TableName clonedTableName3 = TableName.valueOf(name.getMethodName() + "3-" - + System.currentTimeMillis()); - admin.cloneSnapshot(snapshotName2, clonedTableName3); - verifyRowCount(TEST_UTIL, clonedTableName3, snapshot0Rows); - - // Delete the cloned tables - TEST_UTIL.deleteTable(clonedTableName2); - TEST_UTIL.deleteTable(clonedTableName3); - admin.deleteSnapshot(snapshotName2); - } - - @Test - public void testCloneSnapshotAfterSplittingRegion() throws IOException, InterruptedException { - // Turn off the CatalogJanitor - admin.catalogJanitorSwitch(false); - - try { - List regionInfos = admin.getRegions(tableName); - RegionReplicaUtil.removeNonDefaultRegions(regionInfos); - - // Split the first region - splitRegion(regionInfos.get(0)); - - // Take a snapshot - admin.snapshot(snapshotName2, tableName); - - // Clone the snapshot to another table - TableName clonedTableName = TableName.valueOf(name.getMethodName() + "-" - + System.currentTimeMillis()); - admin.cloneSnapshot(snapshotName2, clonedTableName); - SnapshotTestingUtils.waitForTableToBeOnline(TEST_UTIL, clonedTableName); - - RegionStates regionStates = - TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager().getRegionStates(); - - // The region count of the cloned table should be the same as the one of the original table - int openRegionCountOfOriginalTable = - regionStates.getRegionByStateOfTable(tableName).get(RegionState.State.OPEN).size(); - int openRegionCountOfClonedTable = - regionStates.getRegionByStateOfTable(clonedTableName).get(RegionState.State.OPEN).size(); - assertEquals(openRegionCountOfOriginalTable, openRegionCountOfClonedTable); - - int splitRegionCountOfOriginalTable = - regionStates.getRegionByStateOfTable(tableName).get(RegionState.State.SPLIT).size(); - int splitRegionCountOfClonedTable = - regionStates.getRegionByStateOfTable(clonedTableName).get(RegionState.State.SPLIT).size(); - assertEquals(splitRegionCountOfOriginalTable, splitRegionCountOfClonedTable); - - TEST_UTIL.deleteTable(clonedTableName); - } finally { - admin.catalogJanitorSwitch(true); - } - } - - // ========================================================================== - // Helpers - // ========================================================================== - - private void waitCleanerRun() throws InterruptedException { - TEST_UTIL.getMiniHBaseCluster().getMaster().getHFileCleaner().choreForTesting(); - } - - protected void verifyRowCount(final HBaseTestingUtility util, final TableName tableName, - long expectedRows) throws IOException { - SnapshotTestingUtils.verifyRowCount(util, tableName, expectedRows); - } - - protected void splitRegion(final RegionInfo regionInfo) throws IOException { - byte[][] splitPoints = Bytes.split(regionInfo.getStartKey(), regionInfo.getEndKey(), 1); - admin.split(regionInfo.getTable(), splitPoints[1]); - } -} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientAfterSplittingRegion.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientAfterSplittingRegion.java new file mode 100644 index 000000000000..65513f8a930b --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientAfterSplittingRegion.java @@ -0,0 +1,53 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestCloneSnapshotFromClientAfterSplittingRegion + extends CloneSnapshotFromClientAfterSplittingRegionTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestCloneSnapshotFromClientAfterSplittingRegion.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientCloneLinksAfterDelete.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientCloneLinksAfterDelete.java new file mode 100644 index 000000000000..e5f1fad20eb5 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientCloneLinksAfterDelete.java @@ -0,0 +1,54 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestCloneSnapshotFromClientCloneLinksAfterDelete + extends CloneSnapshotFromClientCloneLinksAfterDeleteTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestCloneSnapshotFromClientCloneLinksAfterDelete.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } + +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientError.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientError.java new file mode 100644 index 000000000000..93c2388e3e81 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientError.java @@ -0,0 +1,52 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestCloneSnapshotFromClientError extends CloneSnapshotFromClientErrorTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestCloneSnapshotFromClientError.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientNormal.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientNormal.java new file mode 100644 index 000000000000..c7730d0ea682 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientNormal.java @@ -0,0 +1,52 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestCloneSnapshotFromClientNormal extends CloneSnapshotFromClientNormalTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestCloneSnapshotFromClientNormal.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java index 24591c040114..0dee20b7de5f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide3.java @@ -33,7 +33,9 @@ import java.util.concurrent.CountDownLatch; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; +import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeUnit; +import java.util.concurrent.atomic.AtomicBoolean; import java.util.concurrent.atomic.AtomicInteger; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; @@ -51,6 +53,7 @@ import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor; import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment; import org.apache.hadoop.hbase.coprocessor.RegionObserver; +import org.apache.hadoop.hbase.exceptions.UnknownProtocolException; import org.apache.hadoop.hbase.ipc.CoprocessorRpcUtils; import org.apache.hadoop.hbase.ipc.ServerRpcController; import org.apache.hadoop.hbase.protobuf.generated.MultiRowMutationProtos; @@ -64,6 +67,7 @@ import org.apache.hadoop.hbase.util.Pair; import org.junit.After; import org.junit.AfterClass; +import org.junit.Assert; import org.junit.Before; import org.junit.BeforeClass; import org.junit.ClassRule; @@ -827,8 +831,8 @@ public void testMultiRowMutations() throws Exception, Throwable { } }); ExecutorService cpService = Executors.newSingleThreadExecutor(); + AtomicBoolean exceptionDuringMutateRows = new AtomicBoolean(); cpService.execute(() -> { - boolean threw; Put put1 = new Put(row); Put put2 = new Put(rowLocked); put1.addColumn(FAMILY, QUALIFIER, value1); @@ -842,26 +846,25 @@ public void testMultiRowMutations() throws Exception, Throwable { org.apache.hadoop.hbase.protobuf.generated.ClientProtos.MutationProto.MutationType.PUT, put2)) .build(); table.coprocessorService(MultiRowMutationProtos.MultiRowMutationService.class, - ROW, ROW, + ROW, ROW, (MultiRowMutationProtos.MultiRowMutationService exe) -> { ServerRpcController controller = new ServerRpcController(); CoprocessorRpcUtils.BlockingRpcCallback rpcCallback = new CoprocessorRpcUtils.BlockingRpcCallback<>(); exe.mutateRows(controller, request, rpcCallback); + if (controller.failedOnException() && !(controller.getFailedOn() instanceof UnknownProtocolException)) { + exceptionDuringMutateRows.set(true); + } return rpcCallback.get(); }); - threw = false; } catch (Throwable ex) { - threw = true; - } - if (!threw) { - // Can't call fail() earlier because the catch would eat it. - fail("This cp should fail because the target lock is blocked by previous put"); + LOG.error("encountered " + ex); } }); cpService.shutdown(); cpService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); - WaitingForMultiMutationsObserver observer = find(tableName, WaitingForMultiMutationsObserver.class); + WaitingForMultiMutationsObserver observer = find(tableName, + WaitingForMultiMutationsObserver.class); observer.latch.countDown(); putService.shutdown(); putService.awaitTermination(Long.MAX_VALUE, TimeUnit.DAYS); @@ -875,6 +878,9 @@ public void testMultiRowMutations() throws Exception, Throwable { assertTrue(Bytes.equals(r1.getValue(FAMILY, QUALIFIER), value0)); } assertNoLocks(tableName); + if (!exceptionDuringMutateRows.get()) { + fail("This cp should fail because the target lock is blocked by previous put"); + } } } @@ -1052,4 +1058,77 @@ public RegionScanner postScannerOpen(final ObserverContext list = new ArrayList<>(); + /* + * The first scan rpc should return a result with 2 cells, because 3MB + 4MB > 4MB; The second + * scan rpc should return a result with 3 cells, because reach the batch limit = 3; The + * mayHaveMoreCellsInRow in last result should be false in the scan rpc. BTW, the + * moreResultsInRegion also would be false. Finally, the client should collect all the cells + * into two result: 2+3 -> 3+2; + */ + while ((result = scanner.next()) != null) { + list.add(result); + } + + Assert.assertEquals(5, list.stream().mapToInt(Result::size).sum()); + Assert.assertEquals(2, list.size()); + Assert.assertEquals(3, list.get(0).size()); + Assert.assertEquals(2, list.get(1).size()); + } + + scan = new Scan(); + scan.withStartRow(ROW).withStopRow(ROW).addFamily(FAMILY).setBatch(2) + .setMaxResultSize(4 * 1024 * 1024); + try (ResultScanner scanner = table.getScanner(scan)) { + List list = new ArrayList<>(); + while ((result = scanner.next()) != null) { + list.add(result); + } + Assert.assertEquals(5, list.stream().mapToInt(Result::size).sum()); + Assert.assertEquals(3, list.size()); + Assert.assertEquals(2, list.get(0).size()); + Assert.assertEquals(2, list.get(1).size()); + Assert.assertEquals(1, list.get(2).size()); + } + } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHbck.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHbck.java index 86652d84e42b..7680845cce50 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHbck.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHbck.java @@ -19,17 +19,28 @@ package org.apache.hadoop.hbase.client; import static junit.framework.TestCase.assertTrue; +import static org.junit.Assert.assertEquals; import java.io.IOException; +import java.util.Arrays; +import java.util.List; +import java.util.stream.Collectors; + import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.master.RegionState; +import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; +import org.apache.hadoop.hbase.master.procedure.TableProcedureInterface; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; +import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; +import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.testclassification.ClientTests; import org.apache.hadoop.hbase.testclassification.LargeTests; -import org.junit.After; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.Threads; import org.junit.AfterClass; -import org.junit.Before; import org.junit.BeforeClass; import org.junit.ClassRule; import org.junit.Rule; @@ -52,23 +63,19 @@ public class TestHbck { private static final Logger LOG = LoggerFactory.getLogger(TestHbck.class); private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); - private Admin admin; - private Hbck hbck; @Rule public TestName name = new TestName(); - private static final TableName tableName = TableName.valueOf(TestHbck.class.getSimpleName()); + private static final TableName TABLE_NAME = TableName.valueOf(TestHbck.class.getSimpleName()); + + private static ProcedureExecutor procExec; @BeforeClass public static void setUpBeforeClass() throws Exception { - TEST_UTIL.getConfiguration().setInt("hbase.regionserver.msginterval", 100); - TEST_UTIL.getConfiguration().setInt("hbase.client.pause", 250); - TEST_UTIL.getConfiguration().setInt("hbase.client.retries.number", 6); - TEST_UTIL.getConfiguration().setBoolean("hbase.master.enabletable.roundrobin", true); TEST_UTIL.startMiniCluster(3); - - TEST_UTIL.createTable(tableName, "family1"); + TEST_UTIL.createMultiRegionTable(TABLE_NAME, Bytes.toBytes("family1"), 5); + procExec = TEST_UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor(); } @AfterClass @@ -76,29 +83,102 @@ public static void tearDownAfterClass() throws Exception { TEST_UTIL.shutdownMiniCluster(); } - @Before - public void setUp() throws Exception { - this.admin = TEST_UTIL.getAdmin(); - this.hbck = TEST_UTIL.getHbck(); - } + public static class SuspendProcedure extends + ProcedureTestingUtility.NoopProcedure implements TableProcedureInterface { + public SuspendProcedure() { + super(); + } - @After - public void tearDown() throws Exception { - for (HTableDescriptor htd : this.admin.listTables()) { - TEST_UTIL.deleteTable(htd.getTableName()); + @Override + protected Procedure[] execute(final MasterProcedureEnv env) + throws ProcedureSuspendedException { + // Always suspend the procedure + throw new ProcedureSuspendedException(); } - this.hbck.close(); + + @Override + public TableName getTableName() { + return TABLE_NAME; + } + + @Override + public TableOperationType getTableOperationType() { + return TableOperationType.READ; + } + } + + @Test + public void testBypassProcedure() throws Exception { + // SuspendProcedure + final SuspendProcedure proc = new SuspendProcedure(); + long procId = procExec.submitProcedure(proc); + Thread.sleep(500); + + //bypass the procedure + List pids = Arrays.asList(procId); + List results = + TEST_UTIL.getHbck().bypassProcedure(pids, 30000, false, false); + assertTrue("Failed to by pass procedure!", results.get(0)); + TEST_UTIL.waitFor(5000, () -> proc.isSuccess() && proc.isBypass()); + LOG.info("{} finished", proc); } @Test public void testSetTableStateInMeta() throws IOException { + Hbck hbck = TEST_UTIL.getHbck(); // set table state to DISABLED - hbck.setTableStateInMeta(new TableState(tableName, TableState.State.DISABLED)); + hbck.setTableStateInMeta(new TableState(TABLE_NAME, TableState.State.DISABLED)); // Method {@link Hbck#setTableStateInMeta()} returns previous state, which in this case // will be DISABLED TableState prevState = - hbck.setTableStateInMeta(new TableState(tableName, TableState.State.ENABLED)); + hbck.setTableStateInMeta(new TableState(TABLE_NAME, TableState.State.ENABLED)); assertTrue("Incorrect previous state! expeced=DISABLED, found=" + prevState.getState(), prevState.isDisabled()); } + + @Test + public void testAssigns() throws IOException { + Hbck hbck = TEST_UTIL.getHbck(); + try (Admin admin = TEST_UTIL.getConnection().getAdmin()) { + List regions = admin.getRegions(TABLE_NAME); + for (RegionInfo ri: regions) { + RegionState rs = TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager(). + getRegionStates().getRegionState(ri.getEncodedName()); + LOG.info("RS: {}", rs.toString()); + } + List pids = hbck.unassigns(regions.stream().map(r -> r.getEncodedName()). + collect(Collectors.toList())); + waitOnPids(pids); + for (RegionInfo ri: regions) { + RegionState rs = TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager(). + getRegionStates().getRegionState(ri.getEncodedName()); + LOG.info("RS: {}", rs.toString()); + assertTrue(rs.toString(), rs.isClosed()); + } + pids = hbck.assigns(regions.stream().map(r -> r.getEncodedName()). + collect(Collectors.toList())); + waitOnPids(pids); + for (RegionInfo ri: regions) { + RegionState rs = TEST_UTIL.getHBaseCluster().getMaster().getAssignmentManager(). + getRegionStates().getRegionState(ri.getEncodedName()); + LOG.info("RS: {}", rs.toString()); + assertTrue(rs.toString(), rs.isOpened()); + } + // What happens if crappy region list passed? + pids = hbck.assigns(Arrays.stream(new String [] {"a", "some rubbish name"}). + collect(Collectors.toList())); + for (long pid: pids) { + assertEquals(org.apache.hadoop.hbase.procedure2.Procedure.NO_PROC_ID, pid); + } + } + } + + private void waitOnPids(List pids) { + for (Long pid: pids) { + while (!TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(). + isFinished(pid)) { + Threads.sleep(100); + } + } + } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.java new file mode 100644 index 000000000000..e22f6dca4816 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.java @@ -0,0 +1,156 @@ +/** + * + * 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.client; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.regionserver.InvalidMutationDurabilityException; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({ MediumTests.class, ClientTests.class }) +public class TestInvalidMutationDurabilityException { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestInvalidMutationDurabilityException.class); + + private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); + + private static TableName TABLE_NOT_REPLICATE = TableName.valueOf("TableNotReplicate"); + + private static TableName TABLE_NEED_REPLICATE = TableName.valueOf("TableNeedReplicate"); + + private static byte[] CF = Bytes.toBytes("cf"); + + private static byte[] CQ = Bytes.toBytes("cq"); + + private static Table tableNotReplicate; + + private static Table tableNeedReplicate; + + @BeforeClass + public static void setUp() throws Exception { + UTIL.startMiniCluster(); + UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_NOT_REPLICATE) + .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF).build()).build()); + UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_NEED_REPLICATE) + .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF) + .setScope(HConstants.REPLICATION_SCOPE_GLOBAL).build()).build()); + tableNotReplicate = UTIL.getConnection().getTable(TABLE_NOT_REPLICATE); + tableNeedReplicate = UTIL.getConnection().getTable(TABLE_NEED_REPLICATE); + } + + @AfterClass + public static void tearDown() throws Exception { + UTIL.getAdmin().disableTable(TABLE_NOT_REPLICATE); + UTIL.getAdmin().disableTable(TABLE_NEED_REPLICATE); + UTIL.getAdmin().deleteTable(TABLE_NOT_REPLICATE); + UTIL.getAdmin().deleteTable(TABLE_NEED_REPLICATE); + UTIL.shutdownMiniCluster(); + } + + private Put newPutWithSkipWAL() { + Put put = new Put(Bytes.toBytes("row")); + put.addColumn(CF, CQ, Bytes.toBytes("value")); + put.setDurability(Durability.SKIP_WAL); + return put; + } + + @Test + public void testPutToTableNotReplicate() throws Exception { + tableNotReplicate.put(newPutWithSkipWAL()); + } + + @Test(expected = InvalidMutationDurabilityException.class) + public void testPutToTableNeedReplicate() throws Exception { + tableNeedReplicate.put(newPutWithSkipWAL()); + } + + private Delete newDeleteWithSkipWAL() { + Delete delete = new Delete(Bytes.toBytes("row")); + delete.addColumn(CF, CQ); + delete.setDurability(Durability.SKIP_WAL); + return delete; + } + + @Test + public void testDeleteToTableNotReplicate() throws Exception { + tableNotReplicate.delete(newDeleteWithSkipWAL()); + } + + @Test(expected = InvalidMutationDurabilityException.class) + public void testDeleteToTableNeedReplicate() throws Exception { + tableNeedReplicate.delete(newDeleteWithSkipWAL()); + } + + private Append newAppendWithSkipWAL() { + Append append = new Append(Bytes.toBytes("row")); + append.addColumn(CF, CQ, Bytes.toBytes("value")); + append.setDurability(Durability.SKIP_WAL); + return append; + } + + @Test + public void testAppendToTableNotReplicate() throws Exception { + tableNotReplicate.append(newAppendWithSkipWAL()); + } + + @Test(expected = InvalidMutationDurabilityException.class) + public void testAppendToTableNeedReplicate() throws Exception { + tableNeedReplicate.append(newAppendWithSkipWAL()); + } + + private Increment newIncrementWithSkipWAL() { + Increment increment = new Increment(Bytes.toBytes("row")); + increment.addColumn(CF, CQ, 1); + increment.setDurability(Durability.SKIP_WAL); + return increment; + } + + @Test + public void testIncrementToTableNotReplicate() throws Exception { + tableNotReplicate.increment(newIncrementWithSkipWAL()); + } + + @Test(expected = InvalidMutationDurabilityException.class) + public void testIncrementToTableNeedReplicate() throws Exception { + tableNeedReplicate.increment(newIncrementWithSkipWAL()); + } + + @Test + public void testCheckWithMutateToTableNotReplicate() throws Exception { + tableNotReplicate.checkAndMutate(Bytes.toBytes("row"), CF).qualifier(CQ).ifNotExists() + .thenPut(newPutWithSkipWAL()); + } + + @Test(expected = InvalidMutationDurabilityException.class) + public void testCheckWithMutateToTableNeedReplicate() throws Exception { + tableNeedReplicate.checkAndMutate(Bytes.toBytes("row"), CF).qualifier(CQ).ifNotExists() + .thenPut(newPutWithSkipWAL()); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientAfterSplittingRegion.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientAfterSplittingRegion.java new file mode 100644 index 000000000000..a9e2b542e6f1 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientAfterSplittingRegion.java @@ -0,0 +1,67 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.master.cleaner.TimeToLiveHFileCleaner; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobCloneSnapshotFromClientAfterSplittingRegion + extends CloneSnapshotFromClientAfterSplittingRegionTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobCloneSnapshotFromClientAfterSplittingRegion.class); + + protected static void setupConfiguration() { + CloneSnapshotFromClientTestBase.setupConfiguration(); + TEST_UTIL.getConfiguration().setLong(TimeToLiveHFileCleaner.TTL_CONF_KEY, 0); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + setupConfiguration(); + TEST_UTIL.startMiniCluster(3); + } + + @Override + protected void createTable() throws IOException, InterruptedException { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, + SnapshotTestingUtils.getSplitKeys(), getNumReplicas(), FAMILY); + } + + @Override + protected int numRowsToLoad() { + return 20; + } + + @Override + protected int countRows(Table table) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientCloneLinksAfterDelete.java similarity index 57% rename from hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClient.java rename to hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientCloneLinksAfterDelete.java index 069ec7affa70..1cae7a06bcc7 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClient.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientCloneLinksAfterDelete.java @@ -17,16 +17,11 @@ */ package org.apache.hadoop.hbase.client; -import static org.junit.Assert.assertEquals; - import java.io.IOException; import java.io.InterruptedIOException; import java.util.Optional; import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.coprocessor.ObserverContext; import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor; @@ -42,28 +37,47 @@ import org.apache.hadoop.hbase.util.Bytes; import org.junit.BeforeClass; import org.junit.ClassRule; -import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; -/** - * Test clone snapshots from the client - */ -@Category({LargeTests.class, ClientTests.class}) -public class TestMobCloneSnapshotFromClient extends TestCloneSnapshotFromClient { +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobCloneSnapshotFromClientCloneLinksAfterDelete + extends CloneSnapshotFromClientCloneLinksAfterDeleteTestBase { @ClassRule public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMobCloneSnapshotFromClient.class); + HBaseClassTestRule.forClass(TestMobCloneSnapshotFromClientCloneLinksAfterDelete.class); private static boolean delayFlush = false; - @Rule - public TestName name = new TestName(); + /** + * This coprocessor is used to delay the flush. + */ + public static class DelayFlushCoprocessor implements RegionCoprocessor, RegionObserver { + + @Override + public Optional getRegionObserver() { + return Optional.of(this); + } + + @Override + public void preFlush(ObserverContext e, + FlushLifeCycleTracker tracker) throws IOException { + if (delayFlush) { + try { + if (Bytes.compareTo(e.getEnvironment().getRegionInfo().getStartKey(), + HConstants.EMPTY_START_ROW) != 0) { + Thread.sleep(100); + } + } catch (InterruptedException e1) { + throw new InterruptedIOException(e1.getMessage()); + } + } + } + } protected static void setupConfiguration() { - TestCloneSnapshotFromClient.setupConfiguration(); + CloneSnapshotFromClientTestBase.setupConfiguration(); TEST_UTIL.getConfiguration().setLong(TimeToLiveHFileCleaner.TTL_CONF_KEY, 0); TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); } @@ -75,42 +89,20 @@ public static void setUpBeforeClass() throws Exception { } @Override - protected void createTableAndSnapshots() throws Exception { - // create Table and disable it - createMobTable(TEST_UTIL, tableName, SnapshotTestingUtils.getSplitKeys(), getNumReplicas(), + protected void createTable() throws IOException, InterruptedException { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, + SnapshotTestingUtils.getSplitKeys(), getNumReplicas(), DelayFlushCoprocessor.class.getName(), FAMILY); - delayFlush = false; - admin.disableTable(tableName); - - // take an empty snapshot - admin.snapshot(emptySnapshot, tableName); - - Connection c = ConnectionFactory.createConnection(TEST_UTIL.getConfiguration()); - Table table = c.getTable(tableName); - try { - // enable table and insert data - admin.enableTable(tableName); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 20, FAMILY); - snapshot0Rows = MobSnapshotTestingUtils.countMobRows(table); - admin.disableTable(tableName); - - // take a snapshot - admin.snapshot(snapshotName0, tableName); - - // enable table and insert more data - admin.enableTable(tableName); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 20, FAMILY); - snapshot1Rows = MobSnapshotTestingUtils.countMobRows(table); - admin.disableTable(tableName); + } - // take a snapshot of the updated table - admin.snapshot(snapshotName1, tableName); + @Override + protected int numRowsToLoad() { + return 20; + } - // re-enable table - admin.enableTable(tableName); - } finally { - table.close(); - } + @Override + protected int countRows(Table table) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table); } @Test @@ -121,7 +113,8 @@ public void testCloneLinksAfterDelete() throws IOException, InterruptedException SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 20, FAMILY); long tid = System.currentTimeMillis(); byte[] snapshotName3 = Bytes.toBytes("snaptb3-" + tid); - TableName clonedTableName3 = TableName.valueOf(name.getMethodName() + System.currentTimeMillis()); + TableName clonedTableName3 = + TableName.valueOf(name.getMethodName() + System.currentTimeMillis()); admin.snapshot(snapshotName3, tableName); delayFlush = false; int snapshot3Rows = -1; @@ -135,54 +128,4 @@ public void testCloneLinksAfterDelete() throws IOException, InterruptedException admin.disableTable(clonedTableName3); admin.deleteTable(clonedTableName3); } - - @Override - protected void verifyRowCount(final HBaseTestingUtility util, final TableName tableName, - long expectedRows) throws IOException { - MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); - } - - /** - * This coprocessor is used to delay the flush. - */ - public static class DelayFlushCoprocessor implements RegionCoprocessor, RegionObserver { - - @Override - public Optional getRegionObserver() { - return Optional.of(this); - } - - @Override - public void preFlush(ObserverContext e, - FlushLifeCycleTracker tracker) throws IOException { - if (delayFlush) { - try { - if (Bytes.compareTo(e.getEnvironment().getRegionInfo().getStartKey(), - HConstants.EMPTY_START_ROW) != 0) { - Thread.sleep(100); - } - } catch (InterruptedException e1) { - throw new InterruptedIOException(e1.getMessage()); - } - } - } - } - - private void createMobTable(final HBaseTestingUtility util, final TableName tableName, - final byte[][] splitKeys, int regionReplication, final byte[]... families) throws IOException, - InterruptedException { - HTableDescriptor htd = new HTableDescriptor(tableName); - htd.setRegionReplication(regionReplication); - htd.addCoprocessor(DelayFlushCoprocessor.class.getName()); - for (byte[] family : families) { - HColumnDescriptor hcd = new HColumnDescriptor(family); - hcd.setMobEnabled(true); - hcd.setMobThreshold(0L); - htd.addFamily(hcd); - } - util.getAdmin().createTable(htd, splitKeys); - SnapshotTestingUtils.waitForTableToBeOnline(util, tableName); - assertEquals((splitKeys.length + 1) * regionReplication, - util.getAdmin().getTableRegions(tableName).size()); - } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientError.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientError.java new file mode 100644 index 000000000000..b691e6090d28 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientError.java @@ -0,0 +1,66 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.master.cleaner.TimeToLiveHFileCleaner; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobCloneSnapshotFromClientError extends CloneSnapshotFromClientErrorTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobCloneSnapshotFromClientError.class); + + protected static void setupConfiguration() { + CloneSnapshotFromClientTestBase.setupConfiguration(); + TEST_UTIL.getConfiguration().setLong(TimeToLiveHFileCleaner.TTL_CONF_KEY, 0); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + setupConfiguration(); + TEST_UTIL.startMiniCluster(3); + } + + @Override + protected void createTable() throws IOException, InterruptedException { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, + SnapshotTestingUtils.getSplitKeys(), getNumReplicas(), FAMILY); + } + + @Override + protected int numRowsToLoad() { + return 20; + } + + @Override + protected int countRows(Table table) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientNormal.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientNormal.java new file mode 100644 index 000000000000..94b938e502a4 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobCloneSnapshotFromClientNormal.java @@ -0,0 +1,74 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.master.cleaner.TimeToLiveHFileCleaner; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobCloneSnapshotFromClientNormal extends CloneSnapshotFromClientNormalTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobCloneSnapshotFromClientNormal.class); + + protected static void setupConfiguration() { + CloneSnapshotFromClientTestBase.setupConfiguration(); + TEST_UTIL.getConfiguration().setLong(TimeToLiveHFileCleaner.TTL_CONF_KEY, 0); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + setupConfiguration(); + TEST_UTIL.startMiniCluster(3); + } + + @Override + protected void createTable() throws IOException, InterruptedException { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, + SnapshotTestingUtils.getSplitKeys(), getNumReplicas(), FAMILY); + } + + @Override + protected int numRowsToLoad() { + return 20; + } + + @Override + protected int countRows(Table table) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table); + } + + @Override + protected void verifyRowCount(final HBaseTestingUtility util, final TableName tableName, + long expectedRows) throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientAfterSplittingRegions.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientAfterSplittingRegions.java new file mode 100644 index 000000000000..1135bd3e0a5f --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientAfterSplittingRegions.java @@ -0,0 +1,67 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobRestoreSnapshotFromClientAfterSplittingRegions + extends RestoreSnapshotFromClientAfterSplittingRegionsTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClientAfterSplittingRegions.class); + + @BeforeClass + public static void setupCluster() throws Exception { + setupConf(TEST_UTIL.getConfiguration()); + TEST_UTIL.startMiniCluster(3); + } + + protected static void setupConf(Configuration conf) { + RestoreSnapshotFromClientTestBase.setupConf(conf); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @Override + protected void createTable() throws Exception { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + @Override + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + } + + @Override + protected int countRows(Table table, byte[]... families) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table, families); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientAfterTruncate.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientAfterTruncate.java new file mode 100644 index 000000000000..0abe83d89371 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientAfterTruncate.java @@ -0,0 +1,67 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobRestoreSnapshotFromClientAfterTruncate + extends RestoreSnapshotFromClientAfterTruncateTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClientAfterTruncate.class); + + @BeforeClass + public static void setupCluster() throws Exception { + setupConf(TEST_UTIL.getConfiguration()); + TEST_UTIL.startMiniCluster(3); + } + + protected static void setupConf(Configuration conf) { + RestoreSnapshotFromClientTestBase.setupConf(conf); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @Override + protected void createTable() throws Exception { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + @Override + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + } + + @Override + protected int countRows(Table table, byte[]... families) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table, families); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientClone.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientClone.java new file mode 100644 index 000000000000..475236f821ac --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientClone.java @@ -0,0 +1,66 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobRestoreSnapshotFromClientClone extends RestoreSnapshotFromClientCloneTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClientClone.class); + + @BeforeClass + public static void setupCluster() throws Exception { + setupConf(TEST_UTIL.getConfiguration()); + TEST_UTIL.startMiniCluster(3); + } + + protected static void setupConf(Configuration conf) { + RestoreSnapshotFromClientTestBase.setupConf(conf); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @Override + protected void createTable() throws Exception { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + @Override + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + } + + @Override + protected int countRows(Table table, byte[]... families) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table, families); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientGetCompactionState.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientGetCompactionState.java new file mode 100644 index 000000000000..c4d6ec3ab290 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientGetCompactionState.java @@ -0,0 +1,67 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobRestoreSnapshotFromClientGetCompactionState + extends RestoreSnapshotFromClientGetCompactionStateTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClientGetCompactionState.class); + + @BeforeClass + public static void setupCluster() throws Exception { + setupConf(TEST_UTIL.getConfiguration()); + TEST_UTIL.startMiniCluster(3); + } + + protected static void setupConf(Configuration conf) { + RestoreSnapshotFromClientTestBase.setupConf(conf); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @Override + protected void createTable() throws Exception { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + @Override + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + } + + @Override + protected int countRows(Table table, byte[]... families) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table, families); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientSchemaChange.java similarity index 72% rename from hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClient.java rename to hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientSchemaChange.java index ae8175c3c7d7..3e3233170ecd 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClient.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientSchemaChange.java @@ -21,7 +21,6 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HColumnDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.mob.MobConstants; import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; @@ -31,15 +30,13 @@ import org.junit.ClassRule; import org.junit.experimental.categories.Category; -/** - * Test restore snapshots from the client - */ -@Category({ClientTests.class, LargeTests.class}) -public class TestMobRestoreSnapshotFromClient extends TestRestoreSnapshotFromClient { +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobRestoreSnapshotFromClientSchemaChange + extends RestoreSnapshotFromClientSchemaChangeTestBase { @ClassRule public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClient.class); + HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClientSchemaChange.class); @BeforeClass public static void setupCluster() throws Exception { @@ -48,7 +45,7 @@ public static void setupCluster() throws Exception { } protected static void setupConf(Configuration conf) { - TestRestoreSnapshotFromClient.setupConf(conf); + RestoreSnapshotFromClientTestBase.setupConf(conf); TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); } @@ -58,21 +55,19 @@ protected void createTable() throws Exception { } @Override - protected HColumnDescriptor getTestRestoreSchemaChangeHCD() { - HColumnDescriptor hcd = new HColumnDescriptor(TEST_FAMILY2); - hcd.setMobEnabled(true); - hcd.setMobThreshold(3L); - return hcd; + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); } @Override - protected void verifyRowCount(final HBaseTestingUtility util, final TableName tableName, - long expectedRows) throws IOException { - MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + protected int countRows(Table table, byte[]... families) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table, families); } @Override - protected int countRows(final Table table, final byte[]... families) throws IOException { - return MobSnapshotTestingUtils.countMobRows(table, families); + protected ColumnFamilyDescriptor getTestRestoreSchemaChangeHCD() { + return ColumnFamilyDescriptorBuilder.newBuilder(TEST_FAMILY2).setMobEnabled(true) + .setMobThreshold(3L).build(); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientSimple.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientSimple.java new file mode 100644 index 000000000000..c0e7379c001f --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMobRestoreSnapshotFromClientSimple.java @@ -0,0 +1,67 @@ +/** + * 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.client; + +import java.io.IOException; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.mob.MobConstants; +import org.apache.hadoop.hbase.snapshot.MobSnapshotTestingUtils; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; + +@Category({ LargeTests.class, ClientTests.class }) +public class TestMobRestoreSnapshotFromClientSimple + extends RestoreSnapshotFromClientSimpleTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMobRestoreSnapshotFromClientSimple.class); + + @BeforeClass + public static void setupCluster() throws Exception { + setupConf(TEST_UTIL.getConfiguration()); + TEST_UTIL.startMiniCluster(3); + } + + protected static void setupConf(Configuration conf) { + RestoreSnapshotFromClientTestBase.setupConf(conf); + TEST_UTIL.getConfiguration().setInt(MobConstants.MOB_FILE_CACHE_SIZE_KEY, 0); + } + + @Override + protected void createTable() throws Exception { + MobSnapshotTestingUtils.createMobTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); + } + + @Override + protected void verifyRowCount(HBaseTestingUtility util, TableName tableName, long expectedRows) + throws IOException { + MobSnapshotTestingUtils.verifyMobRowCount(util, tableName, expectedRows); + } + + @Override + protected int countRows(Table table, byte[]... families) throws IOException { + return MobSnapshotTestingUtils.countMobRows(table, families); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRegionLocationCaching.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRegionLocationCaching.java new file mode 100644 index 000000000000..0134276acb28 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRegionLocationCaching.java @@ -0,0 +1,177 @@ +/** + * 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.client; + +import static org.junit.Assert.assertNotEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.List; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({MediumTests.class, ClientTests.class}) +public class TestRegionLocationCaching { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRegionLocationCaching.class); + + private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); + private static int SLAVES = 1; + private static int PER_REGIONSERVER_QUEUE_SIZE = 100000; + private static TableName TABLE_NAME = TableName.valueOf("TestRegionLocationCaching"); + private static byte[] FAMILY = Bytes.toBytes("testFamily"); + private static byte[] QUALIFIER = Bytes.toBytes("testQualifier"); + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + TEST_UTIL.startMiniCluster(SLAVES); + TEST_UTIL.createTable(TABLE_NAME, new byte[][] { FAMILY }); + TEST_UTIL.waitUntilAllRegionsAssigned(TABLE_NAME); + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + TEST_UTIL.shutdownMiniCluster(); + } + + @Test + public void testCachingForHTableMultiplexerSinglePut() throws Exception { + HTableMultiplexer multiplexer = + new HTableMultiplexer(TEST_UTIL.getConfiguration(), PER_REGIONSERVER_QUEUE_SIZE); + byte[] row = Bytes.toBytes("htable_multiplexer_single_put"); + byte[] value = Bytes.toBytes("value"); + + Put put = new Put(row); + put.addColumn(FAMILY, QUALIFIER, value); + assertTrue("Put request not accepted by multiplexer queue", multiplexer.put(TABLE_NAME, put)); + + checkRegionLocationIsCached(TABLE_NAME, multiplexer.getConnection()); + checkExistence(TABLE_NAME, row, FAMILY, QUALIFIER); + + multiplexer.close(); + } + + @Test + public void testCachingForHTableMultiplexerMultiPut() throws Exception { + HTableMultiplexer multiplexer = + new HTableMultiplexer(TEST_UTIL.getConfiguration(), PER_REGIONSERVER_QUEUE_SIZE); + + List multiput = new ArrayList(); + for (int i = 0; i < 10; i++) { + Put put = new Put(Bytes.toBytes("htable_multiplexer_multi_put" + i)); + byte[] value = Bytes.toBytes("value_" + i); + put.addColumn(FAMILY, QUALIFIER, value); + multiput.add(put); + } + + List failedPuts = multiplexer.put(TABLE_NAME, multiput); + assertNull("All put requests were not accepted by multiplexer queue", failedPuts); + + checkRegionLocationIsCached(TABLE_NAME, multiplexer.getConnection()); + for (int i = 0; i < 10; i++) { + checkExistence(TABLE_NAME, Bytes.toBytes("htable_multiplexer_multi_put" + i), FAMILY, + QUALIFIER); + } + + multiplexer.close(); + } + + @Test + public void testCachingForHTableSinglePut() throws Exception { + byte[] row = Bytes.toBytes("htable_single_put"); + byte[] value = Bytes.toBytes("value"); + + Put put = new Put(row); + put.addColumn(FAMILY, QUALIFIER, value); + + try (Table table = TEST_UTIL.getConnection().getTable(TABLE_NAME)) { + table.put(put); + } + + checkRegionLocationIsCached(TABLE_NAME, TEST_UTIL.getConnection()); + checkExistence(TABLE_NAME, row, FAMILY, QUALIFIER); + } + + @Test + public void testCachingForHTableMultiPut() throws Exception { + List multiput = new ArrayList(); + for (int i = 0; i < 10; i++) { + Put put = new Put(Bytes.toBytes("htable_multi_put" + i)); + byte[] value = Bytes.toBytes("value_" + i); + put.addColumn(FAMILY, QUALIFIER, value); + multiput.add(put); + } + + try (Table table = TEST_UTIL.getConnection().getTable(TABLE_NAME)) { + table.put(multiput); + } + checkRegionLocationIsCached(TABLE_NAME, TEST_UTIL.getConnection()); + for (int i = 0; i < 10; i++) { + checkExistence(TABLE_NAME, Bytes.toBytes("htable_multi_put" + i), FAMILY, QUALIFIER); + } + } + + /** + * Method to check whether the cached region location is non-empty for the given table. It repeats + * the same check several times as clearing of cache by some async operations may not reflect + * immediately. + */ + private void checkRegionLocationIsCached(final TableName tableName, final Connection conn) + throws InterruptedException, IOException { + for (int count = 0; count < 50; count++) { + int number = ((ConnectionImplementation) conn).getNumberOfCachedRegionLocations(tableName); + assertNotEquals("Expected non-zero number of cached region locations", 0, number); + Thread.sleep(100); + } + } + + /** + * Method to check whether the passed row exists in the given table + */ + private static void checkExistence(final TableName tableName, final byte[] row, + final byte[] family, final byte[] qualifier) throws Exception { + // verify that the row exists + Result r; + Get get = new Get(row); + get.addColumn(family, qualifier); + int nbTry = 0; + try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { + do { + assertTrue("Failed to get row after " + nbTry + " tries", nbTry < 50); + nbTry++; + Thread.sleep(100); + r = table.get(get); + } while (r == null || r.getValue(family, qualifier) == null); + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClient.java deleted file mode 100644 index 138ec44e274a..000000000000 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClient.java +++ /dev/null @@ -1,396 +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.client; - -import static org.junit.Assert.assertEquals; -import static org.junit.Assert.assertFalse; -import static org.junit.Assert.fail; - -import java.io.IOException; -import java.util.HashSet; -import java.util.List; -import java.util.Set; -import org.apache.hadoop.conf.Configuration; -import org.apache.hadoop.fs.Path; -import org.apache.hadoop.hbase.HBaseClassTestRule; -import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HColumnDescriptor; -import org.apache.hadoop.hbase.HConstants; -import org.apache.hadoop.hbase.HTableDescriptor; -import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.master.MasterFileSystem; -import org.apache.hadoop.hbase.master.snapshot.SnapshotManager; -import org.apache.hadoop.hbase.regionserver.NoSuchColumnFamilyException; -import org.apache.hadoop.hbase.snapshot.CorruptedSnapshotException; -import org.apache.hadoop.hbase.snapshot.SnapshotTestingUtils; -import org.apache.hadoop.hbase.testclassification.ClientTests; -import org.apache.hadoop.hbase.testclassification.LargeTests; -import org.apache.hadoop.hbase.util.Bytes; -import org.apache.hadoop.hbase.util.FSUtils; -import org.junit.After; -import org.junit.AfterClass; -import org.junit.Before; -import org.junit.BeforeClass; -import org.junit.ClassRule; -import org.junit.Rule; -import org.junit.Test; -import org.junit.experimental.categories.Category; -import org.junit.rules.TestName; - -/** - * Test restore snapshots from the client - */ -@Category({LargeTests.class, ClientTests.class}) -public class TestRestoreSnapshotFromClient { - - @ClassRule - public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRestoreSnapshotFromClient.class); - - protected final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); - - protected final byte[] FAMILY = Bytes.toBytes("cf"); - protected final byte[] TEST_FAMILY2 = Bytes.toBytes("cf2"); - - protected TableName tableName; - protected byte[] emptySnapshot; - protected byte[] snapshotName0; - protected byte[] snapshotName1; - protected byte[] snapshotName2; - protected int snapshot0Rows; - protected int snapshot1Rows; - protected Admin admin; - - @Rule - public TestName name = new TestName(); - - @BeforeClass - public static void setupCluster() throws Exception { - setupConf(TEST_UTIL.getConfiguration()); - TEST_UTIL.startMiniCluster(3); - } - - protected static void setupConf(Configuration conf) { - TEST_UTIL.getConfiguration().setBoolean(SnapshotManager.HBASE_SNAPSHOT_ENABLED, true); - TEST_UTIL.getConfiguration().setInt("hbase.hstore.compactionThreshold", 10); - TEST_UTIL.getConfiguration().setInt("hbase.regionserver.msginterval", 100); - TEST_UTIL.getConfiguration().setInt("hbase.client.pause", 250); - TEST_UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 6); - TEST_UTIL.getConfiguration().setBoolean( - "hbase.master.enabletable.roundrobin", true); - } - - @AfterClass - public static void tearDownAfterClass() throws Exception { - TEST_UTIL.shutdownMiniCluster(); - } - - /** - * Initialize the tests with a table filled with some data - * and two snapshots (snapshotName0, snapshotName1) of different states. - * The tableName, snapshotNames and the number of rows in the snapshot are initialized. - */ - @Before - public void setup() throws Exception { - this.admin = TEST_UTIL.getAdmin(); - - long tid = System.currentTimeMillis(); - tableName = TableName.valueOf(name.getMethodName() + "-" + tid); - emptySnapshot = Bytes.toBytes("emptySnaptb-" + tid); - snapshotName0 = Bytes.toBytes("snaptb0-" + tid); - snapshotName1 = Bytes.toBytes("snaptb1-" + tid); - snapshotName2 = Bytes.toBytes("snaptb2-" + tid); - - // create Table and disable it - createTable(); - admin.disableTable(tableName); - - // take an empty snapshot - admin.snapshot(emptySnapshot, tableName); - - // enable table and insert data - admin.enableTable(tableName); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); - try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { - snapshot0Rows = countRows(table); - } - admin.disableTable(tableName); - - // take a snapshot - admin.snapshot(snapshotName0, tableName); - - // enable table and insert more data - admin.enableTable(tableName); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); - try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { - snapshot1Rows = countRows(table); - } - } - - protected void createTable() throws Exception { - SnapshotTestingUtils.createTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); - } - - @After - public void tearDown() throws Exception { - TEST_UTIL.deleteTable(tableName); - SnapshotTestingUtils.deleteAllSnapshots(TEST_UTIL.getAdmin()); - SnapshotTestingUtils.deleteArchiveDirectory(TEST_UTIL); - } - - @Test - public void testRestoreSnapshot() throws IOException { - verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); - admin.disableTable(tableName); - admin.snapshot(snapshotName1, tableName); - // Restore from snapshot-0 - admin.restoreSnapshot(snapshotName0); - admin.enableTable(tableName); - verifyRowCount(TEST_UTIL, tableName, snapshot0Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - - // Restore from emptySnapshot - admin.disableTable(tableName); - admin.restoreSnapshot(emptySnapshot); - admin.enableTable(tableName); - verifyRowCount(TEST_UTIL, tableName, 0); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - - // Restore from snapshot-1 - admin.disableTable(tableName); - admin.restoreSnapshot(snapshotName1); - admin.enableTable(tableName); - verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - - // Restore from snapshot-1 - TEST_UTIL.deleteTable(tableName); - admin.restoreSnapshot(snapshotName1); - verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - } - - protected int getNumReplicas() { - return 1; - } - - protected HColumnDescriptor getTestRestoreSchemaChangeHCD() { - return new HColumnDescriptor(TEST_FAMILY2); - } - - @Test - public void testRestoreSchemaChange() throws Exception { - Table table = TEST_UTIL.getConnection().getTable(tableName); - - // Add one column family and put some data in it - admin.disableTable(tableName); - admin.addColumnFamily(tableName, getTestRestoreSchemaChangeHCD()); - admin.enableTable(tableName); - assertEquals(2, table.getTableDescriptor().getFamilies().size()); - HTableDescriptor htd = admin.getTableDescriptor(tableName); - assertEquals(2, htd.getFamilies().size()); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, TEST_FAMILY2); - long snapshot2Rows = snapshot1Rows + 500L; - assertEquals(snapshot2Rows, countRows(table)); - assertEquals(500, countRows(table, TEST_FAMILY2)); - Set fsFamilies = getFamiliesFromFS(tableName); - assertEquals(2, fsFamilies.size()); - - // Take a snapshot - admin.disableTable(tableName); - admin.snapshot(snapshotName2, tableName); - - // Restore the snapshot (without the cf) - admin.restoreSnapshot(snapshotName0); - admin.enableTable(tableName); - assertEquals(1, table.getTableDescriptor().getFamilies().size()); - try { - countRows(table, TEST_FAMILY2); - fail("family '" + Bytes.toString(TEST_FAMILY2) + "' should not exists"); - } catch (NoSuchColumnFamilyException e) { - // expected - } - assertEquals(snapshot0Rows, countRows(table)); - htd = admin.getTableDescriptor(tableName); - assertEquals(1, htd.getFamilies().size()); - fsFamilies = getFamiliesFromFS(tableName); - assertEquals(1, fsFamilies.size()); - - // Restore back the snapshot (with the cf) - admin.disableTable(tableName); - admin.restoreSnapshot(snapshotName2); - admin.enableTable(tableName); - htd = admin.getTableDescriptor(tableName); - assertEquals(2, htd.getFamilies().size()); - assertEquals(2, table.getTableDescriptor().getFamilies().size()); - assertEquals(500, countRows(table, TEST_FAMILY2)); - assertEquals(snapshot2Rows, countRows(table)); - fsFamilies = getFamiliesFromFS(tableName); - assertEquals(2, fsFamilies.size()); - table.close(); - } - - @Test - public void testCloneSnapshotOfCloned() throws IOException, InterruptedException { - TableName clonedTableName = TableName.valueOf(name.getMethodName() + "-" + - System.currentTimeMillis()); - admin.cloneSnapshot(snapshotName0, clonedTableName); - verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(clonedTableName, admin, getNumReplicas()); - admin.disableTable(clonedTableName); - admin.snapshot(snapshotName2, clonedTableName); - TEST_UTIL.deleteTable(clonedTableName); - waitCleanerRun(); - - admin.cloneSnapshot(snapshotName2, clonedTableName); - verifyRowCount(TEST_UTIL, clonedTableName, snapshot0Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(clonedTableName, admin, getNumReplicas()); - TEST_UTIL.deleteTable(clonedTableName); - } - - @Test - public void testCloneAndRestoreSnapshot() throws IOException, InterruptedException { - TEST_UTIL.deleteTable(tableName); - waitCleanerRun(); - - admin.cloneSnapshot(snapshotName0, tableName); - verifyRowCount(TEST_UTIL, tableName, snapshot0Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - waitCleanerRun(); - - admin.disableTable(tableName); - admin.restoreSnapshot(snapshotName0); - admin.enableTable(tableName); - verifyRowCount(TEST_UTIL, tableName, snapshot0Rows); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - } - - @Test - public void testCorruptedSnapshot() throws IOException, InterruptedException { - SnapshotTestingUtils.corruptSnapshot(TEST_UTIL, Bytes.toString(snapshotName0)); - TableName cloneName = TableName.valueOf(name.getMethodName() + "-" + - System.currentTimeMillis()); - try { - admin.cloneSnapshot(snapshotName0, cloneName); - fail("Expected CorruptedSnapshotException, got succeeded cloneSnapshot()"); - } catch (CorruptedSnapshotException e) { - // Got the expected corruption exception. - // check for no references of the cloned table. - assertFalse(admin.tableExists(cloneName)); - } catch (Exception e) { - fail("Expected CorruptedSnapshotException got: " + e); - } - } - - @Test - public void testRestoreSnapshotAfterSplittingRegions() throws IOException, InterruptedException { - List regionInfos = admin.getRegions(tableName); - RegionReplicaUtil.removeNonDefaultRegions(regionInfos); - - // Split the first region - splitRegion(regionInfos.get(0)); - - // Take a snapshot - admin.snapshot(snapshotName1, tableName); - - // Load more data - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); - - // Split the second region - splitRegion(regionInfos.get(1)); - - // Restore the snapshot - admin.disableTable(tableName); - admin.restoreSnapshot(snapshotName1); - admin.enableTable(tableName); - - verifyRowCount(TEST_UTIL, tableName, snapshot1Rows); - } - - @Test - public void testRestoreSnapshotAfterTruncate() throws Exception { - TableName tableName = TableName.valueOf("testRestoreSnapshotAfterTruncate"); - SnapshotTestingUtils.createTable(TEST_UTIL, tableName, getNumReplicas(), FAMILY); - SnapshotTestingUtils.loadData(TEST_UTIL, tableName, 500, FAMILY); - int numOfRows = 0; - - try (Table table = TEST_UTIL.getConnection().getTable(tableName)) { - numOfRows = countRows(table); - } - // take snapshot - admin.snapshot("snap", tableName); - admin.disableTable(tableName); - admin.truncateTable(tableName, false); - admin.disableTable(tableName); - admin.restoreSnapshot("snap"); - - admin.enableTable(tableName); - verifyRowCount(TEST_UTIL, tableName, numOfRows); - SnapshotTestingUtils.verifyReplicasCameOnline(tableName, admin, getNumReplicas()); - } - - @Test(timeout = 30000) - public void testGetCompactionStateAfterRestoringSnapshot() throws IOException, - InterruptedException { - // Take a snapshot - admin.snapshot(snapshotName1, tableName); - - // Restore the snapshot - admin.disableTable(tableName); - admin.restoreSnapshot(snapshotName1); - - // Get the compaction state of the restored table - CompactionState compactionState = admin.getCompactionState(tableName); - - // The compactionState should be NONE because the table is disabled - assertEquals(CompactionState.NONE, compactionState); - } - - // ========================================================================== - // Helpers - // ========================================================================== - private void waitCleanerRun() throws InterruptedException { - TEST_UTIL.getMiniHBaseCluster().getMaster().getHFileCleaner().choreForTesting(); - } - - private Set getFamiliesFromFS(final TableName tableName) throws IOException { - MasterFileSystem mfs = TEST_UTIL.getMiniHBaseCluster().getMaster().getMasterFileSystem(); - Set families = new HashSet<>(); - Path tableDir = FSUtils.getTableDir(mfs.getRootDir(), tableName); - for (Path regionDir: FSUtils.getRegionDirs(mfs.getFileSystem(), tableDir)) { - for (Path familyDir: FSUtils.getFamilyDirs(mfs.getFileSystem(), regionDir)) { - families.add(familyDir.getName()); - } - } - return families; - } - - protected void verifyRowCount(final HBaseTestingUtility util, final TableName tableName, - long expectedRows) throws IOException { - SnapshotTestingUtils.verifyRowCount(util, tableName, expectedRows); - } - - protected int countRows(final Table table, final byte[]... families) throws IOException { - return TEST_UTIL.countRows(table, families); - } - - protected void splitRegion(final RegionInfo regionInfo) throws IOException { - byte[][] splitPoints = Bytes.split(regionInfo.getStartKey(), regionInfo.getEndKey(), 1); - admin.split(regionInfo.getTable(), splitPoints[1]); - } -} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientAfterSplittingRegions.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientAfterSplittingRegions.java new file mode 100644 index 000000000000..499bfc6843c1 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientAfterSplittingRegions.java @@ -0,0 +1,53 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientAfterSplittingRegions + extends RestoreSnapshotFromClientAfterSplittingRegionsTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientAfterSplittingRegions.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientAfterTruncate.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientAfterTruncate.java new file mode 100644 index 000000000000..6ce0fb3622d2 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientAfterTruncate.java @@ -0,0 +1,53 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientAfterTruncate + extends RestoreSnapshotFromClientAfterTruncateTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientAfterTruncate.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientClone.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientClone.java new file mode 100644 index 000000000000..e9704584cf1a --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientClone.java @@ -0,0 +1,52 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientClone extends RestoreSnapshotFromClientCloneTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientClone.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientGetCompactionState.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientGetCompactionState.java new file mode 100644 index 000000000000..85eba79d1326 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientGetCompactionState.java @@ -0,0 +1,53 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientGetCompactionState + extends RestoreSnapshotFromClientGetCompactionStateTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientGetCompactionState.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientSchemaChange.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientSchemaChange.java new file mode 100644 index 000000000000..0dd9b7b879ce --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientSchemaChange.java @@ -0,0 +1,53 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientSchemaChange + extends RestoreSnapshotFromClientSchemaChangeTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientSchemaChange.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientSimple.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientSimple.java new file mode 100644 index 000000000000..f498e72f1f69 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientSimple.java @@ -0,0 +1,52 @@ +/** + * 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.client; + +import java.util.Arrays; +import java.util.List; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.junit.ClassRule; +import org.junit.experimental.categories.Category; +import org.junit.runner.RunWith; +import org.junit.runners.Parameterized; +import org.junit.runners.Parameterized.Parameter; +import org.junit.runners.Parameterized.Parameters; + +@RunWith(Parameterized.class) +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientSimple extends RestoreSnapshotFromClientSimpleTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientSimple.class); + + @Parameter + public int numReplicas; + + @Parameters(name = "{index}: regionReplication={0}") + public static List params() { + return Arrays.asList(new Object[] { 1 }, new Object[] { 3 }); + } + + @Override + protected int getNumReplicas() { + return numReplicas; + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientWithRegionReplicas.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientWithRegionReplicas.java index d301098693ad..ea47e9d27f22 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientWithRegionReplicas.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestRestoreSnapshotFromClientWithRegionReplicas.java @@ -28,14 +28,13 @@ import org.junit.Test; import org.junit.experimental.categories.Category; - -@Category({LargeTests.class, ClientTests.class}) -public class TestRestoreSnapshotFromClientWithRegionReplicas extends - TestRestoreSnapshotFromClient { +@Category({ LargeTests.class, ClientTests.class }) +public class TestRestoreSnapshotFromClientWithRegionReplicas + extends RestoreSnapshotFromClientTestBase { @ClassRule public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientWithRegionReplicas.class); + HBaseClassTestRule.forClass(TestRestoreSnapshotFromClientWithRegionReplicas.class); @Override protected int getNumReplicas() { @@ -54,8 +53,8 @@ public void testOnlineSnapshotAfterSplittingRegions() throws IOException, Interr admin.snapshot(snapshotName1, tableName); // Clone the snapshot to another table - TableName clonedTableName = TableName.valueOf(name.getMethodName() + "-" + - System.currentTimeMillis()); + TableName clonedTableName = + TableName.valueOf(name.getMethodName() + "-" + System.currentTimeMillis()); admin.cloneSnapshot(snapshotName1, clonedTableName); verifyRowCount(TEST_UTIL, clonedTableName, snapshot1Rows); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestScannersFromClientSide.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestScannersFromClientSide.java index 6803a2e0e252..5e8d107d4f58 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestScannersFromClientSide.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestScannersFromClientSide.java @@ -17,6 +17,8 @@ */ package org.apache.hadoop.hbase.client; +import static org.apache.hadoop.hbase.HConstants.RPC_CODEC_CONF_KEY; +import static org.apache.hadoop.hbase.ipc.RpcClient.DEFAULT_CODEC_CLASS; import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; @@ -608,6 +610,30 @@ public void testGetRowOffset() throws Exception { "Testing offset + multiple CFs + maxResults"); } + @Test + public void testScanRawDeleteFamilyVersion() throws Exception { + TableName tableName = TableName.valueOf(name.getMethodName()); + TEST_UTIL.createTable(tableName, FAMILY); + Configuration conf = new Configuration(TEST_UTIL.getConfiguration()); + conf.set(RPC_CODEC_CONF_KEY, ""); + conf.set(DEFAULT_CODEC_CLASS, ""); + try (Connection connection = ConnectionFactory.createConnection(conf); + Table table = connection.getTable(tableName)) { + Delete delete = new Delete(ROW); + delete.addFamilyVersion(FAMILY, 0L); + table.delete(delete); + Scan scan = new Scan(ROW).setRaw(true); + ResultScanner scanner = table.getScanner(scan); + int count = 0; + while (scanner.next() != null) { + count++; + } + assertEquals(1, count); + } finally { + TEST_UTIL.deleteTable(tableName); + } + } + /** * Test from client side for scan while the region is reopened * on the same region server. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestTableOperationException.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestTableOperationException.java new file mode 100644 index 000000000000..2bb948e528dc --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestTableOperationException.java @@ -0,0 +1,222 @@ +/** + * 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.client; + +import java.io.IOException; +import java.util.List; +import java.util.Optional; + +import org.apache.hadoop.hbase.Cell; +import org.apache.hadoop.hbase.DoNotRetryIOException; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.coprocessor.ObserverContext; +import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor; +import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment; +import org.apache.hadoop.hbase.coprocessor.RegionObserver; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.wal.WALEdit; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({MediumTests.class, ClientTests.class}) +public class TestTableOperationException { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestTableOperationException.class); + + private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); + + private static TableName TABLE_DONOT_RETRY = TableName.valueOf("TableDoNotRetry"); + + private static TableName TABLE_RETRY = TableName.valueOf("TableRetry"); + + private static Table tableDoNotRetry; + + private static Table tableRetry; + + private static byte[] CF = Bytes.toBytes("cf"); + + private static byte[] CQ = Bytes.toBytes("cq"); + + @BeforeClass + public static void setUp() throws Exception { + UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 2); + UTIL.startMiniCluster(); + UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_DONOT_RETRY) + .setCoprocessor(ThrowDoNotRetryIOExceptionCoprocessor.class.getName()) + .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF).build()).build()); + UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_RETRY) + .setCoprocessor(ThrowIOExceptionCoprocessor.class.getName()) + .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF).build()).build()); + tableDoNotRetry = UTIL.getConnection().getTable(TABLE_DONOT_RETRY); + tableRetry = UTIL.getConnection().getTable(TABLE_RETRY); + } + + @AfterClass + public static void tearDown() throws Exception { + UTIL.getAdmin().disableTable(TABLE_DONOT_RETRY); + UTIL.getAdmin().disableTable(TABLE_RETRY); + UTIL.getAdmin().deleteTable(TABLE_DONOT_RETRY); + UTIL.getAdmin().deleteTable(TABLE_RETRY); + UTIL.shutdownMiniCluster(); + } + + @Test(expected = DoNotRetryIOException.class) + public void testGetWithDoNotRetryIOException() throws Exception { + tableDoNotRetry.get(new Get(Bytes.toBytes("row")).addColumn(CF, CQ)); + } + + @Test(expected = DoNotRetryIOException.class) + public void testPutWithDoNotRetryIOException() throws Exception { + tableDoNotRetry.put(new Put(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value"))); + } + + @Test(expected = DoNotRetryIOException.class) + public void testDeleteWithDoNotRetryIOException() throws Exception { + tableDoNotRetry.delete(new Delete(Bytes.toBytes("row")).addColumn(CF, CQ)); + } + + @Test(expected = DoNotRetryIOException.class) + public void testAppendWithDoNotRetryIOException() throws Exception { + tableDoNotRetry + .append(new Append(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value"))); + } + + @Test(expected = DoNotRetryIOException.class) + public void testIncrementWithDoNotRetryIOException() throws Exception { + tableDoNotRetry.increment(new Increment(Bytes.toBytes("row")).addColumn(CF, CQ, 1)); + } + + @Test(expected = RetriesExhaustedException.class) + public void testGetWithIOException() throws Exception { + tableRetry.get(new Get(Bytes.toBytes("row")).addColumn(CF, CQ)); + } + + @Test(expected = RetriesExhaustedException.class) + public void testPutWithIOException() throws Exception { + tableRetry.put(new Put(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value"))); + } + + @Test(expected = RetriesExhaustedException.class) + public void testDeleteWithIOException() throws Exception { + tableRetry.delete(new Delete(Bytes.toBytes("row")).addColumn(CF, CQ)); + } + + @Test(expected = RetriesExhaustedException.class) + public void testAppendWithIOException() throws Exception { + tableRetry.append(new Append(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value"))); + } + + @Test(expected = RetriesExhaustedException.class) + public void testIncrementWithIOException() throws Exception { + tableRetry.increment(new Increment(Bytes.toBytes("row")).addColumn(CF, CQ, 1)); + } + + public static class ThrowDoNotRetryIOExceptionCoprocessor + implements RegionCoprocessor, RegionObserver { + + public ThrowDoNotRetryIOExceptionCoprocessor() { + } + + @Override + public Optional getRegionObserver() { + return Optional.of(this); + } + + @Override + public void preGetOp(final ObserverContext e, final Get get, + final List results) throws IOException { + throw new DoNotRetryIOException("Call failed and don't retry"); + } + + @Override + public void prePut(final ObserverContext e, final Put put, + final WALEdit edit, final Durability durability) throws IOException { + throw new DoNotRetryIOException("Call failed and don't retry"); + } + + @Override + public void preDelete(final ObserverContext e, + final Delete delete, final WALEdit edit, final Durability durability) throws IOException { + throw new DoNotRetryIOException("Call failed and don't retry"); + } + + @Override + public Result preIncrement(final ObserverContext e, + final Increment increment) throws IOException { + throw new DoNotRetryIOException("Call failed and don't retry"); + } + + @Override + public Result preAppend(final ObserverContext e, + final Append append) throws IOException { + throw new DoNotRetryIOException("Call failed and don't retry"); + } + } + + public static class ThrowIOExceptionCoprocessor + implements RegionCoprocessor, RegionObserver { + + public ThrowIOExceptionCoprocessor() { + } + + @Override + public Optional getRegionObserver() { + return Optional.of(this); + } + + @Override + public void preGetOp(final ObserverContext e, final Get get, + final List results) throws IOException { + throw new IOException("Call failed and retry"); + } + + @Override + public void prePut(final ObserverContext e, final Put put, + final WALEdit edit, final Durability durability) throws IOException { + throw new IOException("Call failed and retry"); + } + + @Override + public void preDelete(final ObserverContext e, + final Delete delete, final WALEdit edit, final Durability durability) throws IOException { + throw new IOException("Call failed and retry"); + } + + @Override + public Result preIncrement(final ObserverContext e, + final Increment increment) throws IOException { + throw new IOException("Call failed and retry"); + } + + @Override + public Result preAppend(final ObserverContext e, + final Append append) throws IOException { + throw new IOException("Call failed and retry"); + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/replication/TestReplicationAdminForSyncReplication.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/replication/TestReplicationAdminForSyncReplication.java new file mode 100644 index 000000000000..31fd53acda85 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/replication/TestReplicationAdminForSyncReplication.java @@ -0,0 +1,125 @@ +/** + * 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.client.replication; + +import static org.junit.Assert.assertEquals; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.Admin; +import org.apache.hadoop.hbase.replication.ReplicationPeerConfig; +import org.apache.hadoop.hbase.replication.ReplicationPeerConfigBuilder; +import org.apache.hadoop.hbase.testclassification.ClientTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@Category({MediumTests.class, ClientTests.class}) +public class TestReplicationAdminForSyncReplication { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestReplicationAdminForSyncReplication.class); + + private static final Logger LOG = + LoggerFactory.getLogger(TestReplicationAdminForSyncReplication.class); + + private final static HBaseTestingUtility TEST_UTIL = + new HBaseTestingUtility(); + + private static Admin hbaseAdmin; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + TEST_UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 1); + TEST_UTIL.startMiniCluster(); + hbaseAdmin = TEST_UTIL.getAdmin(); + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + hbaseAdmin.close(); + TEST_UTIL.shutdownMiniCluster(); + } + + @Test + public void testAddPeerWithSameTable() throws Exception { + TableName tableName = TableName.valueOf("testAddPeerWithSameTable"); + TEST_UTIL.createTable(tableName, Bytes.toBytes("family")); + + boolean[] success = { true, true, true, true, true, true }; + Thread[] threads = new Thread[5]; + for (int i = 0; i < 5; i++) { + String peerId = "id" + i; + String clusterKey = "127.0.0.1:2181:/hbase" + i; + int index = i; + threads[i] = new Thread(() -> { + try { + hbaseAdmin + .addReplicationPeer(peerId, buildSyncReplicationPeerConfig(clusterKey, tableName)); + } catch (IOException e) { + LOG.error("Failed to add replication peer " + peerId); + success[index] = false; + } + }); + } + for (int i = 0; i < 5; i++) { + threads[i].start(); + } + for (int i = 0; i < 5; i++) { + threads[i].join(); + } + + int successCount = 0; + for (int i = 0; i < 5; i++) { + if (success[i]) { + successCount++; + } + } + assertEquals("Only one peer can be added successfully", 1, successCount); + } + + private ReplicationPeerConfig buildSyncReplicationPeerConfig(String clusterKey, + TableName tableName) throws IOException { + Path rootDir = TEST_UTIL.getDataTestDirOnTestFS("remoteWAL"); + ReplicationPeerConfigBuilder builder = ReplicationPeerConfig.newBuilder(); + builder.setClusterKey(clusterKey); + builder.setRemoteWALDir(rootDir.makeQualified(TEST_UTIL.getTestFileSystem().getUri(), + TEST_UTIL.getTestFileSystem().getWorkingDirectory()).toString()); + builder.setReplicateAllUserTables(false); + Map> tableCfs = new HashMap<>(); + tableCfs.put(tableName, new ArrayList<>()); + builder.setTableCFsMap(tableCfs); + return builder.build(); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestChecksum.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestChecksum.java index dd8ebb35677e..de28422570f2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestChecksum.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestChecksum.java @@ -299,11 +299,9 @@ protected void testChecksumInternals(boolean useTags) throws IOException { long expectedChunks = ChecksumUtil.numChunks( dataSize + HConstants.HFILEBLOCK_HEADER_SIZE, bytesPerChecksum); - LOG.info("testChecksumChunks: pread=" + pread + - ", bytesPerChecksum=" + bytesPerChecksum + - ", fileSize=" + totalSize + - ", dataSize=" + dataSize + - ", expectedChunks=" + expectedChunks); + LOG.info("testChecksumChunks: pread={}, bytesPerChecksum={}, fileSize={}, " + + "dataSize={}, expectedChunks={}, compression={}", pread, bytesPerChecksum, + totalSize, dataSize, expectedChunks, algo.toString()); // Verify hbase checksums. assertEquals(true, hfs.useHBaseChecksum()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlock.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlock.java index f4e6696d7d69..a588341478a6 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlock.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlock.java @@ -376,6 +376,8 @@ private void testInternals() throws IOException { for (Compression.Algorithm algo : COMPRESSION_ALGORITHMS) { for (boolean pread : new boolean[] { false, true }) { for (DataBlockEncoding encoding : DataBlockEncoding.values()) { + LOG.info("testDataBlockEncoding: Compression algorithm={}, pread={}, dataBlockEncoder={}", + algo.toString(), pread, encoding); Path path = new Path(TEST_UTIL.getDataTestDir(), "blocks_v2_" + algo + "_" + encoding.toString()); FSDataOutputStream os = fs.create(path); @@ -534,9 +536,8 @@ protected void testPreviousOffsetInternals() throws IOException { for (boolean pread : BOOLEAN_VALUES) { for (boolean cacheOnWrite : BOOLEAN_VALUES) { Random rand = defaultRandom(); - LOG.info("testPreviousOffset:Compression algorithm: " + algo + - ", pread=" + pread + - ", cacheOnWrite=" + cacheOnWrite); + LOG.info("testPreviousOffset: Compression algorithm={}, pread={}, cacheOnWrite={}", + algo.toString(), pread, cacheOnWrite); Path path = new Path(TEST_UTIL.getDataTestDir(), "prev_offset"); List expectedOffsets = new ArrayList<>(); List expectedPrevOffsets = new ArrayList<>(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlockIndex.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlockIndex.java index be35c74140f6..890ea72d2c1a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlockIndex.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestHFileBlockIndex.java @@ -202,7 +202,7 @@ public HFileBlock readBlock(long offset, long onDiskSize, private void readIndex(boolean useTags) throws IOException { long fileSize = fs.getFileStatus(path).getLen(); - LOG.info("Size of " + path + ": " + fileSize); + LOG.info("Size of {}: {} compression={}", path, fileSize, compr.toString()); FSDataInputStream istream = fs.open(path); HFileContext meta = new HFileContextBuilder() diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestSeekBeforeWithInlineBlocks.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestSeekBeforeWithInlineBlocks.java index f6b6fbc231f4..cadcad6e1ffd 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestSeekBeforeWithInlineBlocks.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestSeekBeforeWithInlineBlocks.java @@ -37,6 +37,7 @@ import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.BloomFilterFactory; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.Bytes; import org.junit.ClassRule; import org.junit.Test; @@ -80,6 +81,8 @@ public class TestSeekBeforeWithInlineBlocks { @Test public void testMultiIndexLevelRandomHFileWithBlooms() throws IOException { conf = TEST_UTIL.getConfiguration(); + TEST_UTIL.getConfiguration().setInt(BloomFilterUtil.PREFIX_LENGTH_KEY, 10); + TEST_UTIL.getConfiguration().set(BloomFilterUtil.DELIMITER_KEY, "#"); // Try out different HFile versions to ensure reverse scan works on each version for (int hfileVersion = HFile.MIN_FORMAT_VERSION_WITH_TAGS; @@ -101,6 +104,8 @@ public void testMultiIndexLevelRandomHFileWithBlooms() throws IOException { conf.setInt(HFileBlockIndex.MAX_CHUNK_SIZE_KEY, indexBlockSize); conf.setInt(BloomFilterFactory.IO_STOREFILE_BLOOM_BLOCK_SIZE, BLOOM_BLOCK_SIZE); + conf.setInt(BloomFilterUtil.PREFIX_LENGTH_KEY, 10); + conf.set(BloomFilterUtil.DELIMITER_KEY, "#"); Cell[] cells = new Cell[NUM_KV]; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/AbstractTestDLS.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/AbstractTestDLS.java index 4b47fa1bc045..a11064db9c30 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/AbstractTestDLS.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/AbstractTestDLS.java @@ -67,7 +67,6 @@ import org.apache.hadoop.hbase.ipc.ServerNotRunningYetException; import org.apache.hadoop.hbase.master.SplitLogManager.TaskBatch; import org.apache.hadoop.hbase.master.assignment.RegionStates; -import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.regionserver.MultiVersionConcurrencyControl; import org.apache.hadoop.hbase.regionserver.Region; @@ -224,10 +223,11 @@ public void testRecoveredEdits() throws Exception { int count = 0; for (RegionInfo hri : regions) { - Path tdir = FSUtils.getTableDir(rootdir, table); + Path tdir = FSUtils.getWALTableDir(conf, table); @SuppressWarnings("deprecation") Path editsdir = WALSplitter - .getRegionDirRecoveredEditsDir(HRegion.getRegionDir(tdir, hri.getEncodedName())); + .getRegionDirRecoveredEditsDir(FSUtils.getWALRegionDir(conf, + tableName, hri.getEncodedName())); LOG.debug("checking edits dir " + editsdir); FileStatus[] files = fs.listStatus(editsdir, new PathFilter() { @Override diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java index 23b0c80c1240..f4c2a33234f2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/MockRegionServer.java @@ -29,7 +29,6 @@ import java.util.Random; import java.util.TreeMap; import java.util.concurrent.ConcurrentSkipListMap; - import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.hbase.Abortable; @@ -38,6 +37,7 @@ import org.apache.hadoop.hbase.ChoreService; import org.apache.hadoop.hbase.CoordinatedStateManager; import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableDescriptors; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.ZooKeeperConnectionException; import org.apache.hadoop.hbase.client.ClusterConnection; @@ -70,10 +70,10 @@ import org.apache.hadoop.hbase.wal.WAL; import org.apache.hadoop.hbase.zookeeper.MetaTableLocator; import org.apache.hadoop.hbase.zookeeper.ZKWatcher; -import org.apache.zookeeper.KeeperException; import org.apache.hbase.thirdparty.com.google.protobuf.RpcController; import org.apache.hbase.thirdparty.com.google.protobuf.ServiceException; + import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.ClearCompactionQueuesRequest; @@ -142,7 +142,7 @@ * store that the get pulls from. */ class MockRegionServer implements AdminProtos.AdminService.BlockingInterface, -ClientProtos.ClientService.BlockingInterface, RegionServerServices { + ClientProtos.ClientService.BlockingInterface, RegionServerServices { private final ServerName sn; private final ZKWatcher zkw; private final Configuration conf; @@ -338,8 +338,7 @@ public RegionServerRpcQuotaManager getRegionServerRpcQuotaManager() { } @Override - public void postOpenDeployTasks(PostOpenDeployContext context) throws KeeperException, - IOException { + public void postOpenDeployTasks(PostOpenDeployContext context) throws IOException { } @Override @@ -710,4 +709,9 @@ public boolean isClusterUp() { public ReplicationSourceService getReplicationSourceService() { return null; } + + @Override + public TableDescriptors getTableDescriptors() { + return null; + } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestCloseAnOpeningRegion.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestCloseAnOpeningRegion.java new file mode 100644 index 000000000000..17cf8f4c12e8 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestCloseAnOpeningRegion.java @@ -0,0 +1,146 @@ +/** + * 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; + +import java.io.IOException; +import java.io.UncheckedIOException; +import java.util.concurrent.CountDownLatch; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.PleaseHoldException; +import org.apache.hadoop.hbase.StartMiniClusterOption; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.Put; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.master.assignment.AssignmentManager; +import org.apache.hadoop.hbase.regionserver.HRegionServer; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.zookeeper.KeeperException; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode; +import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionRequest; +import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.ReportRegionStateTransitionResponse; + +@Category({ MasterTests.class, MediumTests.class }) +public class TestCloseAnOpeningRegion { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestCloseAnOpeningRegion.class); + + private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); + + private static TableName TABLE_NAME = TableName.valueOf("race"); + + private static byte[] CF = Bytes.toBytes("cf"); + + private static volatile CountDownLatch ARRIVE; + + private static volatile CountDownLatch RESUME; + + public static final class MockHMaster extends HMaster { + + public MockHMaster(Configuration conf) throws IOException, KeeperException { + super(conf); + } + + @Override + protected AssignmentManager createAssignmentManager(MasterServices master) { + return new AssignmentManager(master) { + + @Override + public ReportRegionStateTransitionResponse reportRegionStateTransition( + ReportRegionStateTransitionRequest req) throws PleaseHoldException { + ReportRegionStateTransitionResponse resp = super.reportRegionStateTransition(req); + TransitionCode code = req.getTransition(0).getTransitionCode(); + if (code == TransitionCode.OPENED && ARRIVE != null) { + ARRIVE.countDown(); + try { + RESUME.await(); + } catch (InterruptedException e) { + throw new RuntimeException(e); + } + } + return resp; + } + }; + } + } + + @BeforeClass + public static void setUp() throws Exception { + UTIL.getConfiguration().setInt(HConstants.HBASE_RPC_SHORTOPERATION_TIMEOUT_KEY, 60000); + UTIL.startMiniCluster( + StartMiniClusterOption.builder().numRegionServers(2).masterClass(MockHMaster.class).build()); + UTIL.createTable(TABLE_NAME, CF); + UTIL.getAdmin().balancerSwitch(false, true); + } + + @AfterClass + public static void tearDown() throws Exception { + UTIL.shutdownMiniCluster(); + } + + @Test + public void test() throws IOException, InterruptedException { + ARRIVE = new CountDownLatch(1); + RESUME = new CountDownLatch(1); + RegionInfo region = UTIL.getAdmin().getRegions(TABLE_NAME).get(0); + HRegionServer src = UTIL.getRSForFirstRegionInTable(TABLE_NAME); + HRegionServer dst = UTIL.getOtherRegionServer(src); + Thread move0 = new Thread(() -> { + try { + UTIL.getAdmin().move(region.getEncodedNameAsBytes(), + Bytes.toBytes(dst.getServerName().getServerName())); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + }); + move0.start(); + ARRIVE.await(); + Thread move1 = new Thread(() -> { + try { + UTIL.getAdmin().move(region.getEncodedNameAsBytes(), + Bytes.toBytes(src.getServerName().getServerName())); + } catch (IOException e) { + throw new UncheckedIOException(e); + } + }); + move1.start(); + // No simple way to determine when it is safe to go on and produce the race so let's sleep for a + // well... + Thread.sleep(10000); + RESUME.countDown(); + move0.join(); + move1.join(); + try (Table table = UTIL.getConnection().getTable(TABLE_NAME)) { + // make sure that we can write to the table, which means the region is online + table.put(new Put(Bytes.toBytes(0)).addColumn(CF, Bytes.toBytes("cq"), Bytes.toBytes(0))); + } + } +} \ No newline at end of file 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 4e852f8cd56b..73ff789dfdc2 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 @@ -123,7 +123,6 @@ public void testSortExtract(){ DeadServer d = new DeadServer(); - d.add(hostname123); mee.incValue(1); d.add(hostname1234); @@ -164,14 +163,17 @@ public void testClearDeadServer(){ d.add(hostname1234); Assert.assertEquals(2, d.size()); + d.finish(hostname123); d.removeDeadServer(hostname123); Assert.assertEquals(1, d.size()); + d.finish(hostname1234); d.removeDeadServer(hostname1234); Assert.assertTrue(d.isEmpty()); d.add(hostname1234); Assert.assertFalse(d.removeDeadServer(hostname123_2)); Assert.assertEquals(1, d.size()); + d.finish(hostname1234); Assert.assertTrue(d.removeDeadServer(hostname1234)); Assert.assertTrue(d.isEmpty()); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMaster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMaster.java index 81bdb023bdf9..7ba431d57bc5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMaster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMaster.java @@ -20,6 +20,7 @@ import static org.junit.Assert.assertArrayEquals; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; @@ -73,8 +74,7 @@ public class TestMaster { private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); private static final Logger LOG = LoggerFactory.getLogger(TestMaster.class); - private static final TableName TABLENAME = - TableName.valueOf("TestMaster"); + private static final TableName TABLENAME = TableName.valueOf("TestMaster"); private static final byte[] FAMILYNAME = Bytes.toBytes("fam"); private static Admin admin; @@ -263,5 +263,11 @@ public void testBlockingHbkc1WithLockFile() throws IOException { // Assert lock gets put in place again. assertTrue(fs.exists(hbckLockPath)); } + + @Test + public void testMasterBlockCache() { + // Master not carry table in default, so no need to instantiate block cache, too. + assertNull(TEST_UTIL.getMiniHBaseCluster().getMaster().getCacheConfig().getBlockCache()); + } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterRepairMode.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterRepairMode.java new file mode 100644 index 000000000000..22c4cc8a9a9f --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterRepairMode.java @@ -0,0 +1,141 @@ +/* + * 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; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertTrue; +import static org.junit.Assert.fail; + +import java.util.Arrays; +import java.util.stream.Stream; +import java.util.stream.StreamSupport; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.HConstants; +import org.apache.hadoop.hbase.StartMiniClusterOption; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.Connection; +import org.apache.hadoop.hbase.client.Put; +import org.apache.hadoop.hbase.client.Result; +import org.apache.hadoop.hbase.client.ResultScanner; +import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; + +import org.junit.After; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.rules.TestName; + +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +@Category({MasterTests.class, MediumTests.class}) +public class TestMasterRepairMode { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestMasterRepairMode.class); + + @Rule + public TestName name = new TestName(); + + private static final Logger LOG = LoggerFactory.getLogger(TestMasterRepairMode.class); + + private static final byte[] FAMILYNAME = Bytes.toBytes("fam"); + + private static HBaseTestingUtility TEST_UTIL; + + @Before + public void setUp() throws Exception { + TEST_UTIL = new HBaseTestingUtility(); + } + + @After + public void tearDown() throws Exception { + TEST_UTIL.shutdownMiniCluster(); + } + + private void enableMaintenanceMode() { + Configuration c = TEST_UTIL.getConfiguration(); + c.setBoolean(HMaster.MAINTENANCE_MODE, true); + c.setInt("hbase.master.init.timeout.localHBaseCluster", 30000); + } + + @Test + public void testNewCluster() throws Exception { + enableMaintenanceMode(); + + TEST_UTIL.startMiniCluster(StartMiniClusterOption.builder() + .numRegionServers(0) + .numDataNodes(3) + .build()); + + Connection conn = TEST_UTIL.getConnection(); + assertTrue(conn.getAdmin().isMasterInMaintenanceMode()); + + try (Table table = conn.getTable(TableName.META_TABLE_NAME); + ResultScanner scanner = table.getScanner(new Scan())) { + assertNotNull("Could not read meta.", scanner.next()); + } + } + + @Test + public void testExistingCluster() throws Exception { + TableName testRepairMode = TableName.valueOf(name.getMethodName()); + + TEST_UTIL.startMiniCluster(); + Table t = TEST_UTIL.createTable(testRepairMode, FAMILYNAME); + Put p = new Put(Bytes.toBytes("r")); + p.addColumn(FAMILYNAME, Bytes.toBytes("c"), new byte[0]); + t.put(p); + + TEST_UTIL.shutdownMiniHBaseCluster(); + + LOG.info("Starting master-only"); + + enableMaintenanceMode(); + TEST_UTIL.startMiniHBaseCluster(StartMiniClusterOption.builder() + .numRegionServers(0).createRootDir(false).build()); + + Connection conn = TEST_UTIL.getConnection(); + assertTrue(conn.getAdmin().isMasterInMaintenanceMode()); + + try (Table table = conn.getTable(TableName.META_TABLE_NAME); + ResultScanner scanner = table.getScanner(HConstants.TABLE_FAMILY); + Stream results = StreamSupport.stream(scanner.spliterator(), false)) { + assertTrue("Did not find user table records while reading hbase:meta", + results.anyMatch(r -> Arrays.equals(r.getRow(), testRepairMode.getName()))); + } + + try (Table table = conn.getTable(testRepairMode); + ResultScanner scanner = table.getScanner(new Scan())) { + scanner.next(); + fail("Should not be able to access user-space tables in repair mode."); + } catch (Exception e) { + // Expected + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java index 320687756b3d..c0dc72c39a47 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/MockMasterServices.java @@ -58,6 +58,7 @@ import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; import org.apache.hadoop.hbase.procedure2.store.NoopProcedureStore; import org.apache.hadoop.hbase.procedure2.store.ProcedureStore; +import org.apache.hadoop.hbase.procedure2.store.ProcedureStore.ProcedureStoreListener; import org.apache.hadoop.hbase.security.Superusers; import org.apache.hadoop.hbase.util.FSUtils; import org.apache.zookeeper.KeeperException; @@ -220,7 +221,13 @@ private void startProcedureExecutor(final RSProcedureDispatcher remoteDispatcher throws IOException { final Configuration conf = getConfiguration(); this.procedureStore = new NoopProcedureStore(); - this.procedureStore.registerListener(new MasterProcedureEnv.MasterProcedureStoreListener(this)); + this.procedureStore.registerListener(new ProcedureStoreListener() { + + @Override + public void abortProcess() { + abort("The Procedure Store lost the lease", null); + } + }); this.procedureEnv = new MasterProcedureEnv(this, remoteDispatcher != null ? remoteDispatcher : new RSProcedureDispatcher(this)); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestCloseRegionWhileRSCrash.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestCloseRegionWhileRSCrash.java index 3573bd661e98..d34bfbb4f2ca 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestCloseRegionWhileRSCrash.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestCloseRegionWhileRSCrash.java @@ -18,10 +18,10 @@ package org.apache.hadoop.hbase.master.assignment; import java.io.IOException; -import java.util.Iterator; import java.util.concurrent.CountDownLatch; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.ProcedureTestUtil; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; @@ -45,13 +45,6 @@ import org.junit.ClassRule; import org.junit.Test; import org.junit.experimental.categories.Category; -import org.slf4j.Logger; -import org.slf4j.LoggerFactory; - -import org.apache.hbase.thirdparty.com.google.gson.JsonArray; -import org.apache.hbase.thirdparty.com.google.gson.JsonElement; -import org.apache.hbase.thirdparty.com.google.gson.JsonObject; -import org.apache.hbase.thirdparty.com.google.gson.JsonParser; /** * Confirm that we will do backoff when retrying on closing a region, to avoid consuming all the @@ -64,8 +57,6 @@ public class TestCloseRegionWhileRSCrash { public static final HBaseClassTestRule CLASS_RULE = HBaseClassTestRule.forClass(TestCloseRegionWhileRSCrash.class); - private static final Logger LOG = LoggerFactory.getLogger(TestCloseRegionWhileRSCrash.class); - private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); private static TableName TABLE_NAME = TableName.valueOf("Backoff"); @@ -189,25 +180,11 @@ public void testRetryBackoff() throws IOException, InterruptedException { } }); t.start(); - JsonParser parser = new JsonParser(); - long oldTimeout = 0; - int timeoutIncrements = 0; // wait until we enter the WAITING_TIMEOUT state - UTIL.waitFor(30000, () -> getTimeout(parser, UTIL.getAdmin().getProcedures()) > 0); - while (true) { - long timeout = getTimeout(parser, UTIL.getAdmin().getProcedures()); - if (timeout > oldTimeout) { - LOG.info("Timeout incremented, was {}, now is {}, increments={}", timeout, oldTimeout, - timeoutIncrements); - oldTimeout = timeout; - timeoutIncrements++; - if (timeoutIncrements > 3) { - // If we incremented at least twice, break; the backoff is working. - break; - } - } - Thread.sleep(1000); - } + ProcedureTestUtil.waitUntilProcedureWaitingTimeout(UTIL, TransitRegionStateProcedure.class, + 30000); + // wait until the timeout value increase three times + ProcedureTestUtil.waitUntilProcedureTimeoutIncrease(UTIL, TransitRegionStateProcedure.class, 3); // let's close the connection to make sure that the SCP can not update meta successfully UTIL.getMiniHBaseCluster().getMaster().getConnection().close(); RESUME.countDown(); @@ -223,24 +200,4 @@ public void testRetryBackoff() throws IOException, InterruptedException { table.put(new Put(Bytes.toBytes(1)).addColumn(CF, Bytes.toBytes("cq"), Bytes.toBytes(1))); } } - - /** - * @param proceduresAsJSON This is String returned by admin.getProcedures call... an array of - * Procedures as JSON. - * @return The Procedure timeout value parsed from the TRSP. - */ - private long getTimeout(JsonParser parser, String proceduresAsJSON) { - JsonArray array = parser.parse(proceduresAsJSON).getAsJsonArray(); - Iterator iterator = array.iterator(); - while (iterator.hasNext()) { - JsonElement element = iterator.next(); - JsonObject obj = element.getAsJsonObject(); - String className = obj.get("className").getAsString(); - String actualClassName = TransitRegionStateProcedure.class.getName(); - if (className.equals(actualClassName) && obj.has("timeout")) { - return obj.get("timeout").getAsLong(); - } - } - return -1L; - } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestMergeTableRegionsProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestMergeTableRegionsProcedure.java index 36d7583caa2c..b2236904c853 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestMergeTableRegionsProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestMergeTableRegionsProcedure.java @@ -24,7 +24,6 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.MetaTableAccessor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Admin; @@ -38,6 +37,7 @@ import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; import org.apache.hadoop.hbase.procedure2.ProcedureMetrics; import org.apache.hadoop.hbase.procedure2.ProcedureTestingUtility; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -66,8 +66,6 @@ public class TestMergeTableRegionsProcedure { public final TestName name = new TestName(); private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); - private static long nonceGroup = HConstants.NO_NONCE; - private static long nonce = HConstants.NO_NONCE; private static final int initialRegionCount = 4; private final static byte[] FAMILY = Bytes.toBytes("FAMILY"); @@ -108,9 +106,8 @@ public static void cleanupTest() throws Exception { @Before public void setup() throws Exception { resetProcExecutorTestingKillFlag(); - nonceGroup = - MasterProcedureTestingUtility.generateNonceGroup(UTIL.getHBaseCluster().getMaster()); - nonce = MasterProcedureTestingUtility.generateNonce(UTIL.getHBaseCluster().getMaster()); + MasterProcedureTestingUtility.generateNonceGroup(UTIL.getHBaseCluster().getMaster()); + MasterProcedureTestingUtility.generateNonce(UTIL.getHBaseCluster().getMaster()); // Turn off balancer so it doesn't cut in and mess up our placements. admin.balancerSwitch(false, true); // Turn off the meta scanner so it don't remove parent on us. @@ -265,41 +262,49 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new MergeTableRegionsProcedure(procExec.getEnvironment(), regionsToMerge, true)); - // Failing before MERGE_TABLE_REGIONS_CREATE_MERGED_REGION we should trigger the rollback - // NOTE: the 5 (number before MERGE_TABLE_REGIONS_CREATE_MERGED_REGION step) is + // Failing before MERGE_TABLE_REGIONS_UPDATE_META we should trigger the rollback + // NOTE: the 8 (number of MERGE_TABLE_REGIONS_UPDATE_META step) is // hardcoded, so you have to look at this test at least once when you add a new step. - int numberOfSteps = 5; - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps, - true); + int lastStep = 8; + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep, true); + assertEquals(initialRegionCount, UTIL.getAdmin().getRegions(tableName).size()); + UTIL.waitUntilAllRegionsAssigned(tableName); + List regions = UTIL.getMiniHBaseCluster().getRegions(tableName); + assertEquals(initialRegionCount, regions.size()); } @Test public void testMergeWithoutPONR() throws Exception { - final TableName tableName = TableName.valueOf("testMergeWithoutPONR"); - final ProcedureExecutor procExec = getMasterProcedureExecutor(); + try { + final TableName tableName = TableName.valueOf("testMergeWithoutPONR"); + final ProcedureExecutor procExec = getMasterProcedureExecutor(); - List tableRegions = createTable(tableName); + List tableRegions = createTable(tableName); - ProcedureTestingUtility.waitNoProcedureRunning(procExec); - ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true); + ProcedureTestingUtility.waitNoProcedureRunning(procExec); + ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true); - RegionInfo[] regionsToMerge = new RegionInfo[2]; - regionsToMerge[0] = tableRegions.get(0); - regionsToMerge[1] = tableRegions.get(1); + RegionInfo[] regionsToMerge = new RegionInfo[2]; + regionsToMerge[0] = tableRegions.get(0); + regionsToMerge[1] = tableRegions.get(1); - long procId = procExec.submitProcedure( + long procId = procExec.submitProcedure( new MergeTableRegionsProcedure(procExec.getEnvironment(), regionsToMerge, true)); - // Execute until step 9 of split procedure - // NOTE: step 9 is after step MERGE_TABLE_REGIONS_UPDATE_META - MasterProcedureTestingUtility.testRecoveryAndDoubleExecution(procExec, procId, 9, false); + // Execute until step 9 of split procedure + // NOTE: step 9 is after step MERGE_TABLE_REGIONS_UPDATE_META + MasterProcedureTestingUtility.testRecoveryAndDoubleExecution(procExec, procId, 9, false); - // Unset Toggle Kill and make ProcExec work correctly - ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); - MasterProcedureTestingUtility.restartMasterProcedureExecutor(procExec); - ProcedureTestingUtility.waitProcedure(procExec, procId); + // Unset Toggle Kill and make ProcExec work correctly + ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); + MasterProcedureTestingUtility.restartMasterProcedureExecutor(procExec); + ProcedureTestingUtility.waitProcedure(procExec, procId); - assertRegionCount(tableName, initialRegionCount - 1); + assertRegionCount(tableName, initialRegionCount - 1); + } catch (Throwable t) { + LOG.error("error!", t); + throw t; + } } private List createTable(final TableName tableName) throws Exception { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestRegionBypass.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestRegionBypass.java new file mode 100644 index 000000000000..97dc37bc53ba --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestRegionBypass.java @@ -0,0 +1,194 @@ +/** + * 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.assignment; + +import static org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RegionStateTransitionState.REGION_STATE_TRANSITION_OPEN; +import static org.junit.Assert.assertTrue; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.List; +import java.util.concurrent.CountDownLatch; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.Admin; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureSuspendedException; +import org.apache.hadoop.hbase.procedure2.ProcedureYieldException; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.AfterClass; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.rules.TestName; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.RegionStateTransitionState; + + +/** + * Tests bypass on a region assign/unassign + */ +@Category({LargeTests.class}) +public class TestRegionBypass { + private final static Logger LOG = LoggerFactory.getLogger(TestRegionBypass.class); + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRegionBypass.class); + + @Rule + public TestName name = new TestName(); + + private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); + private TableName tableName; + + @BeforeClass + public static void startCluster() throws Exception { + TEST_UTIL.startMiniCluster(2); + } + + @AfterClass + public static void stopCluster() throws Exception { + TEST_UTIL.shutdownMiniCluster(); + } + + @Before + public void before() throws IOException { + this.tableName = TableName.valueOf(this.name.getMethodName()); + // Create a table. Has one region at least. + TEST_UTIL.createTable(this.tableName, Bytes.toBytes("cf")); + + } + + @Test + public void testBypass() throws IOException { + Admin admin = TEST_UTIL.getAdmin(); + MasterProcedureEnv env = + TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor().getEnvironment(); + List regions = admin.getRegions(this.tableName); + for (RegionInfo ri: regions) { + admin.unassign(ri.getRegionName(), false); + } + List pids = new ArrayList<>(regions.size()); + for (RegionInfo ri: regions) { + Procedure p = new StallingAssignProcedure(env, ri, null, false, + RegionStateTransitionState.REGION_STATE_TRANSITION_GET_ASSIGN_CANDIDATE, + RegionStateTransitionState.REGION_STATE_TRANSITION_CONFIRM_OPENED); + pids.add(TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(). + submitProcedure(p)); + } + for (Long pid: pids) { + while (!TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor().isStarted(pid)) { + Thread.currentThread().yield(); + } + } + List> ps = + TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor().getProcedures(); + for (Procedure p: ps) { + if (p instanceof StallingAssignProcedure) { + List bs = TEST_UTIL.getHbck(). + bypassProcedure(Arrays.asList(p.getProcId()), 1000, true, false); + for (Boolean b: bs) { + LOG.info("BYPASSED {} {}", p.getProcId(), b); + } + } + } + // Try and assign WITHOUT override flag. Should fail!. + for (RegionInfo ri: regions) { + try { + admin.assign(ri.getRegionName()); + } catch (Throwable dnrioe) { + // Expected + LOG.info("Expected {}", dnrioe); + } + } + while (!TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(). + getActiveProcIds().isEmpty()) { + Thread.currentThread().yield(); + } + // Now assign with the override flag. + for (RegionInfo ri: regions) { + TEST_UTIL.getHbck().assigns(Arrays.asList(ri.getEncodedName()), true); + } + while (!TEST_UTIL.getHBaseCluster().getMaster().getMasterProcedureExecutor(). + getActiveProcIds().isEmpty()) { + Thread.currentThread().yield(); + } + for (RegionInfo ri: regions) { + assertTrue(ri.toString(), TEST_UTIL.getMiniHBaseCluster().getMaster().getAssignmentManager(). + getRegionStates().isRegionOnline(ri)); + } + } + + /** + * An AssignProcedure that Stalls just before the finish. + */ + public static class StallingAssignProcedure extends TransitRegionStateProcedure{ + public final CountDownLatch latch = new CountDownLatch(2); + + public StallingAssignProcedure(){} + + public StallingAssignProcedure(MasterProcedureEnv env, RegionInfo hri, + ServerName assignCandidate, boolean forceNewPlan, RegionStateTransitionState initialState, + RegionStateTransitionState lastState) { + super(env, hri, assignCandidate, forceNewPlan, initialState, lastState); + init(env); + } + + private void init(MasterProcedureEnv env){ + RegionStateNode regionNode = + env.getAssignmentManager().getRegionStates().getOrCreateRegionStateNode(getRegion()); + regionNode.setProcedure(this); + } + + + @Override + protected Flow executeFromState(MasterProcedureEnv env, RegionStateTransitionState state) + throws ProcedureSuspendedException, ProcedureYieldException, InterruptedException { + switch (state) { + case REGION_STATE_TRANSITION_GET_ASSIGN_CANDIDATE: + LOG.info("LATCH1 {}", this.latch.getCount()); + this.latch.countDown(); + setNextState(REGION_STATE_TRANSITION_OPEN); + return Flow.HAS_MORE_STATE; + case REGION_STATE_TRANSITION_OPEN: + if (latch.getCount() == 0) { + LOG.info("LATCH3 {}", this.latch.getCount()); + return Flow.NO_MORE_STATE; + } else { + LOG.info("LATCH2 {}", this.latch.getCount()); + return Flow.HAS_MORE_STATE; + } + default: + throw new UnsupportedOperationException("unhandled state=" + state); + } + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestSplitTableRegionProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestSplitTableRegionProcedure.java index b9fb5180215e..3f9f960b92fa 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestSplitTableRegionProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/assignment/TestSplitTableRegionProcedure.java @@ -348,7 +348,7 @@ public void testRollbackAndDoubleExecution() throws Exception { final TableName tableName = TableName.valueOf(name.getMethodName()); final ProcedureExecutor procExec = getMasterProcedureExecutor(); - RegionInfo [] regions = MasterProcedureTestingUtility.createTable( + RegionInfo[] regions = MasterProcedureTestingUtility.createTable( procExec, tableName, null, ColumnFamilyName1, ColumnFamilyName2); insertData(tableName); int splitRowNum = startRowNum + rowCount / 2; @@ -366,18 +366,19 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new SplitTableRegionProcedure(procExec.getEnvironment(), regions[0], splitKey)); - // Failing before SPLIT_TABLE_REGION_CREATE_DAUGHTER_REGIONS we should trigger the + // Failing before SPLIT_TABLE_REGION_UPDATE_META we should trigger the // rollback - // NOTE: the 3 (number before SPLIT_TABLE_REGION_CREATE_DAUGHTER_REGIONS step) is + // NOTE: the 7 (number of SPLIT_TABLE_REGION_UPDATE_META step) is // hardcoded, so you have to look at this test at least once when you add a new step. - int numberOfSteps = 3; - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps, + int lastStep = 7; + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep, true); // check that we have only 1 region assertEquals(1, UTIL.getAdmin().getRegions(tableName).size()); - List daughters = UTIL.getMiniHBaseCluster().getRegions(tableName); - assertEquals(1, daughters.size()); - verifyData(daughters.get(0), startRowNum, rowCount, + UTIL.waitUntilAllRegionsAssigned(tableName); + List newRegions = UTIL.getMiniHBaseCluster().getRegions(tableName); + assertEquals(1, newRegions.size()); + verifyData(newRegions.get(0), startRowNum, rowCount, Bytes.toBytes(ColumnFamilyName1), Bytes.toBytes(ColumnFamilyName2)); assertEquals(splitSubmittedCount + 1, splitProcMetrics.getSubmittedCounter().getCount()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestBalancerStatusTagInJMXMetrics.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestBalancerStatusTagInJMXMetrics.java new file mode 100644 index 000000000000..9f566210a879 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestBalancerStatusTagInJMXMetrics.java @@ -0,0 +1,115 @@ +/** + * 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.balancer; + +import static org.junit.Assert.assertEquals; + +import java.util.Random; + +import org.apache.commons.logging.Log; +import org.apache.commons.logging.LogFactory; +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.MiniHBaseCluster; +import org.apache.hadoop.hbase.master.HMaster; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.metrics2.MetricsSource; +import org.apache.hadoop.metrics2.MetricsTag; +import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({ MediumTests.class }) +public class TestBalancerStatusTagInJMXMetrics extends BalancerTestBase { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestBalancerStatusTagInJMXMetrics.class); + + private static final Log LOG = LogFactory.getLog(TestBalancerStatusTagInJMXMetrics.class); + private static HBaseTestingUtility UTIL = new HBaseTestingUtility(); + private static int connectorPort = 61120; + private static HMaster master; + private static MiniHBaseCluster cluster; + private static Configuration conf = null; + + /** + * Setup the environment for the test. + */ + @BeforeClass + public static void setupBeforeClass() throws Exception { + + conf = UTIL.getConfiguration(); + Random rand = new Random(); + for (int i = 0; i < 10; i++) { + do { + int sign = i % 2 == 0 ? 1 : -1; + connectorPort += sign * rand.nextInt(100); + } while (!HBaseTestingUtility.available(connectorPort)); + try { + conf.setInt("regionserver.rmi.registry.port", connectorPort); + cluster = UTIL.startMiniCluster(); + LOG.info("Waiting for active/ready master"); + cluster.waitForActiveAndReadyMaster(); + master = cluster.getMaster(); + break; + } catch (Exception e) { + LOG.debug("Encountered exception when starting mini cluster. Trying port " + connectorPort, + e); + try { + // this is to avoid "IllegalStateException: A mini-cluster is already running" + UTIL.shutdownMiniCluster(); + } catch (Exception ex) { + LOG.debug("Encountered exception shutting down cluster", ex); + } + } + } + } + + @AfterClass + public static void tearDownAfterClass() throws Exception { + UTIL.shutdownMiniCluster(); + } + + /** + * Tests the status change using the Default Metrics System + */ + @Test + public void testJmxMetrics() throws Exception { + + assertEquals(getStatus(), "true"); + master.getLoadBalancer().updateBalancerStatus(false); + assertEquals(getStatus(), "false"); + + } + + /** + * Gets the balancer status tag from the Metrics registry + */ + public String getStatus() throws Exception { + MetricsSource source = + DefaultMetricsSystem.instance().getSource(MetricsBalancerSource.METRICS_JMX_CONTEXT); + if (source instanceof MetricsBalancerSourceImpl) { + MetricsTag status = ((MetricsBalancerSourceImpl) source).getMetricsRegistry() + .getTag(MetricsBalancerSource.BALANCER_STATUS); + return status.value(); + } else { + LOG.warn("Balancer JMX Metrics not registered"); + throw new Exception("MetricsBalancer JMX Context not found"); + } + } + +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java index 3975ec088431..452a501c5877 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/MasterProcedureTestingUtility.java @@ -379,7 +379,7 @@ public static long generateNonce(final HMaster master) { */ public static void testRecoveryAndDoubleExecution( final ProcedureExecutor procExec, final long procId, - final int numSteps, final boolean expectExecRunning) throws Exception { + final int lastStep, final boolean expectExecRunning) throws Exception { ProcedureTestingUtility.waitProcedure(procExec, procId); assertEquals(false, procExec.isRunning()); @@ -397,10 +397,13 @@ public static void testRecoveryAndDoubleExecution( // fix would be get all visited states by the procedure and then check if user speccified // state is in that list. Current assumption of sequential proregression of steps/ states is // made at multiple places so we can keep while condition below for simplicity. - Procedure proc = procExec.getProcedure(procId); + Procedure proc = procExec.getProcedure(procId); int stepNum = proc instanceof StateMachineProcedure ? ((StateMachineProcedure) proc).getCurrentStateId() : 0; - while (stepNum < numSteps) { + for (;;) { + if (stepNum == lastStep) { + break; + } LOG.info("Restart " + stepNum + " exec state=" + proc); ProcedureTestingUtility.assertProcNotYetCompleted(procExec, procId); restartMasterProcedureExecutor(procExec); @@ -507,13 +510,18 @@ public static void testRollbackAndDoubleExecution( // Sometimes there are other procedures still executing (including asynchronously spawned by // procId) and due to KillAndToggleBeforeStoreUpdate flag ProcedureExecutor is stopped before // store update. Let all pending procedures finish normally. - if (!procExec.isRunning()) { - LOG.warn("ProcedureExecutor not running, may have been stopped by pending procedure due to" - + " KillAndToggleBeforeStoreUpdate flag."); - ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); - restartMasterProcedureExecutor(procExec); - ProcedureTestingUtility.waitNoProcedureRunning(procExec); + ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, false); + // check 3 times to confirm that the procedure executor has not been killed + for (int i = 0; i < 3; i++) { + if (!procExec.isRunning()) { + LOG.warn("ProcedureExecutor not running, may have been stopped by pending procedure due" + + " to KillAndToggleBeforeStoreUpdate flag."); + restartMasterProcedureExecutor(procExec); + break; + } + Thread.sleep(1000); } + ProcedureTestingUtility.waitNoProcedureRunning(procExec); } assertEquals(true, procExec.isRunning()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java index 14c8d96b5508..f4fa282478c7 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCloneSnapshotProcedure.java @@ -177,8 +177,8 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new CloneSnapshotProcedure(procExec.getEnvironment(), htd, snapshotDesc)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 2; // failing before CLONE_SNAPSHOT_WRITE_FS_LAYOUT + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); MasterProcedureTestingUtility.validateTableDeletion( UTIL.getHBaseCluster().getMaster(), clonedTableName); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java index 7a5a9fa671d5..eb904b48a473 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateNamespaceProcedure.java @@ -215,8 +215,8 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new CreateNamespaceProcedure(procExec.getEnvironment(), nsd)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 2; // failing before CREATE_NAMESPACE_CREATE_DIRECTORY + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); // Validate the non-existence of namespace try { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java index eed1e41d5ffc..a6fea3712c56 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestCreateTableProcedure.java @@ -186,8 +186,8 @@ private void testRollbackAndDoubleExecution(TableDescriptorBuilder builder) thro long procId = procExec.submitProcedure( new CreateTableProcedure(procExec.getEnvironment(), htd, regions)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 2; // failing before CREATE_TABLE_WRITE_FS_LAYOUT + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); TableName tableName = htd.getTableName(); MasterProcedureTestingUtility.validateTableDeletion(getMaster(), tableName); @@ -239,7 +239,7 @@ protected Flow executeFromState(MasterProcedureEnv env, } } - @Test(timeout = 60000) + @Test public void testOnHDFSFailure() throws Exception { final TableName tableName = TableName.valueOf(name.getMethodName()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java index ef859a3024ff..2f1a984a657a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestDeleteNamespaceProcedure.java @@ -25,10 +25,10 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.NamespaceNotFoundException; import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.constraint.ConstraintException; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; @@ -88,7 +88,7 @@ public void setup() throws Exception { @After public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); - for (HTableDescriptor htd: UTIL.getAdmin().listTables()) { + for (TableDescriptor htd: UTIL.getAdmin().listTableDescriptors()) { LOG.info("Tear down, remove table=" + htd.getTableName()); UTIL.deleteTable(htd.getTableName()); } @@ -200,8 +200,8 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new DeleteNamespaceProcedure(procExec.getEnvironment(), namespaceName)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 2; // failing before DELETE_NAMESPACE_DELETE_FROM_NS_TABLE + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); // Validate the namespace still exists NamespaceDescriptor createdNsDescriptor= diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java index 1eafb292c22f..9a244d30a3f5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestEnableTableProcedure.java @@ -138,8 +138,8 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new EnableTableProcedure(procExec.getEnvironment(), tableName, false)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 3; // fail before ENABLE_TABLE_SET_ENABLING_TABLE_STATE + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); MasterProcedureTestingUtility.validateTableIsDisabled(getMaster(), tableName); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java index 34e7921f2767..e76aacd247c6 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyNamespaceProcedure.java @@ -24,9 +24,9 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; -import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.NamespaceDescriptor; import org.apache.hadoop.hbase.NamespaceNotFoundException; +import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.constraint.ConstraintException; import org.apache.hadoop.hbase.procedure2.Procedure; import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; @@ -81,7 +81,7 @@ public void setup() throws Exception { @After public void tearDown() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(getMasterProcedureExecutor(), false); - for (HTableDescriptor htd: UTIL.getAdmin().listTables()) { + for (TableDescriptor htd: UTIL.getAdmin().listTableDescriptors()) { LOG.info("Tear down, remove table=" + htd.getTableName()); UTIL.deleteTable(htd.getTableName()); } @@ -246,8 +246,8 @@ public void testRollbackAndDoubleExecution() throws Exception { long procId = procExec.submitProcedure( new ModifyNamespaceProcedure(procExec.getEnvironment(), nsd)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 2; // failing before MODIFY_NAMESPACE_UPDATE_NS_TABLE + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); // Validate NamespaceDescriptor currentNsDescriptor = diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java index 9428ff03bb9f..f439549858f2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestModifyTableProcedure.java @@ -22,7 +22,6 @@ import static org.junit.Assert.assertTrue; import java.io.IOException; - import org.apache.hadoop.hbase.DoNotRetryIOException; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HColumnDescriptor; @@ -288,11 +287,10 @@ public void testColumnFamilyAdditionTwiceWithNonce() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true); // Modify multiple properties of the table. - final HTableDescriptor htd = - new HTableDescriptor(UTIL.getAdmin().getTableDescriptor(tableName)); - boolean newCompactionEnableOption = htd.isCompactionEnabled() ? false : true; - htd.setCompactionEnabled(newCompactionEnableOption); - htd.addFamily(new HColumnDescriptor(cf2)); + TableDescriptor td = UTIL.getAdmin().getDescriptor(tableName); + TableDescriptor newTd = + TableDescriptorBuilder.newBuilder(td).setCompactionEnabled(!td.isCompactionEnabled()) + .setColumnFamily(ColumnFamilyDescriptorBuilder.of(cf2)).build(); PerClientRandomNonceGenerator nonceGenerator = PerClientRandomNonceGenerator.get(); long nonceGroup = nonceGenerator.getNonceGroup(); @@ -302,7 +300,7 @@ public void testColumnFamilyAdditionTwiceWithNonce() throws Exception { // Start the Modify procedure && kill the executor final long procId = procExec - .submitProcedure(new ModifyTableProcedure(procExec.getEnvironment(), htd), nonceKey); + .submitProcedure(new ModifyTableProcedure(procExec.getEnvironment(), newTd), nonceKey); // Restart the executor after MODIFY_TABLE_UPDATE_TABLE_DESCRIPTOR and try to add column family // as nonce are there , we should not fail @@ -328,11 +326,11 @@ public boolean execute(int step) throws IOException { } // Validate descriptor - HTableDescriptor currentHtd = UTIL.getAdmin().getTableDescriptor(tableName); - assertEquals(newCompactionEnableOption, currentHtd.isCompactionEnabled()); - assertEquals(3, currentHtd.getFamiliesKeys().size()); - assertTrue(currentHtd.hasFamily(Bytes.toBytes(cf2))); - assertTrue(currentHtd.hasFamily(Bytes.toBytes(cf3))); + TableDescriptor currentHtd = UTIL.getAdmin().getDescriptor(tableName); + assertEquals(!td.isCompactionEnabled(), currentHtd.isCompactionEnabled()); + assertEquals(3, currentHtd.getColumnFamilyCount()); + assertTrue(currentHtd.hasColumnFamily(Bytes.toBytes(cf2))); + assertTrue(currentHtd.hasColumnFamily(Bytes.toBytes(cf3))); // cf2 should be added MasterProcedureTestingUtility.validateTableCreation(UTIL.getHBaseCluster().getMaster(), @@ -351,17 +349,17 @@ public void testRollbackAndDoubleExecutionOnline() throws Exception { ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true); - HTableDescriptor htd = new HTableDescriptor(UTIL.getAdmin().getTableDescriptor(tableName)); - boolean newCompactionEnableOption = htd.isCompactionEnabled() ? false : true; - htd.setCompactionEnabled(newCompactionEnableOption); - htd.addFamily(new HColumnDescriptor(familyName)); + TableDescriptor td = UTIL.getAdmin().getDescriptor(tableName); + TableDescriptor newTd = + TableDescriptorBuilder.newBuilder(td).setCompactionEnabled(!td.isCompactionEnabled()) + .setColumnFamily(ColumnFamilyDescriptorBuilder.of(familyName)).build(); // Start the Modify procedure && kill the executor - long procId = procExec.submitProcedure( - new ModifyTableProcedure(procExec.getEnvironment(), htd)); + long procId = + procExec.submitProcedure(new ModifyTableProcedure(procExec.getEnvironment(), newTd)); - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 3; // failing before MODIFY_TABLE_UPDATE_TABLE_DESCRIPTOR + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); // cf2 should not be present MasterProcedureTestingUtility.validateTableCreation(UTIL.getHBaseCluster().getMaster(), @@ -382,19 +380,19 @@ public void testRollbackAndDoubleExecutionOffline() throws Exception { ProcedureTestingUtility.waitNoProcedureRunning(procExec); ProcedureTestingUtility.setKillAndToggleBeforeStoreUpdate(procExec, true); - HTableDescriptor htd = new HTableDescriptor(UTIL.getAdmin().getTableDescriptor(tableName)); - boolean newCompactionEnableOption = htd.isCompactionEnabled() ? false : true; - htd.setCompactionEnabled(newCompactionEnableOption); - htd.addFamily(new HColumnDescriptor(familyName)); - htd.setRegionReplication(3); + TableDescriptor td = UTIL.getAdmin().getDescriptor(tableName); + TableDescriptor newTd = + TableDescriptorBuilder.newBuilder(td).setCompactionEnabled(!td.isCompactionEnabled()) + .setColumnFamily(ColumnFamilyDescriptorBuilder.of(familyName)).setRegionReplication(3) + .build(); // Start the Modify procedure && kill the executor long procId = procExec.submitProcedure( - new ModifyTableProcedure(procExec.getEnvironment(), htd)); + new ModifyTableProcedure(procExec.getEnvironment(), newTd)); // Restart the executor and rollback the step twice - int numberOfSteps = 0; // failing at pre operation - MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, numberOfSteps); + int lastStep = 3; // failing before MODIFY_TABLE_UPDATE_TABLE_DESCRIPTOR + MasterProcedureTestingUtility.testRollbackAndDoubleExecution(procExec, procId, lastStep); // cf2 should not be present MasterProcedureTestingUtility.validateTableCreation(UTIL.getHBaseCluster().getMaster(), diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java index 7386b2f05adc..32fb173c2eaf 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestProcedurePriority.java @@ -160,13 +160,13 @@ public String explainFailure() throws Exception { rsWithMetaThread.join(); FAIL = false; // verify that the cluster is back - UTIL.waitUntilNoRegionsInTransition(60000); + UTIL.waitUntilNoRegionsInTransition(480000); for (int i = 0; i < TABLE_COUNT; i++) { try (Table table = UTIL.getConnection().getTable(TableName.valueOf(TABLE_NAME_PREFIX + i))) { table.put(new Put(Bytes.toBytes(i)).addColumn(CF, CQ, Bytes.toBytes(i))); } } - UTIL.waitFor(30000, new ExplainingPredicate() { + UTIL.waitFor(60000, new ExplainingPredicate() { @Override public boolean evaluate() throws Exception { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java new file mode 100644 index 000000000000..870f3bf817ad --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/procedure/TestReopenTableRegionsProcedureInfiniteLoop.java @@ -0,0 +1,90 @@ +/** + * 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 org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.RegionInfo; +import org.apache.hadoop.hbase.master.HMaster; +import org.apache.hadoop.hbase.master.ServerManager; +import org.apache.hadoop.hbase.master.assignment.AssignmentManager; +import org.apache.hadoop.hbase.master.assignment.RegionStateNode; +import org.apache.hadoop.hbase.master.assignment.TransitRegionStateProcedure; +import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.util.Bytes; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +/** + * Testcase for HBASE-21330. + */ +@Category({ MasterTests.class, MediumTests.class }) +public class TestReopenTableRegionsProcedureInfiniteLoop { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestReopenTableRegionsProcedureInfiniteLoop.class); + + private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); + + private static TableName TABLE_NAME = TableName.valueOf("InfiniteLoop"); + + private static byte[] CF = Bytes.toBytes("cf"); + + @BeforeClass + public static void setUp() throws Exception { + UTIL.getConfiguration().setInt(ServerManager.WAIT_ON_REGIONSERVERS_MINTOSTART, 1); + UTIL.startMiniCluster(1); + UTIL.createTable(TABLE_NAME, CF); + } + + @AfterClass + public static void tearDown() throws Exception { + UTIL.shutdownMiniCluster(); + } + + @Test + public void testInfiniteLoop() throws IOException { + HMaster master = UTIL.getMiniHBaseCluster().getMaster(); + AssignmentManager am = master.getAssignmentManager(); + ProcedureExecutor exec = master.getMasterProcedureExecutor(); + RegionInfo regionInfo = UTIL.getAdmin().getRegions(TABLE_NAME).get(0); + RegionStateNode regionNode = am.getRegionStates().getRegionStateNode(regionInfo); + long procId; + ReopenTableRegionsProcedure proc = new ReopenTableRegionsProcedure(TABLE_NAME); + regionNode.lock(); + try { + procId = exec.submitProcedure(proc); + UTIL.waitFor(30000, () -> proc.hasLock()); + TransitRegionStateProcedure trsp = + TransitRegionStateProcedure.reopen(exec.getEnvironment(), regionInfo); + regionNode.setProcedure(trsp); + exec.submitProcedure(trsp); + } finally { + regionNode.unlock(); + } + UTIL.waitFor(60000, () -> exec.isFinished(procId)); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/replication/TestModifyPeerProcedureRetryBackoff.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/replication/TestModifyPeerProcedureRetryBackoff.java new file mode 100644 index 000000000000..7566d28e8104 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/replication/TestModifyPeerProcedureRetryBackoff.java @@ -0,0 +1,166 @@ +/** + * 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.replication; + +import java.io.IOException; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.ProcedureTestUtil; +import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; +import org.apache.hadoop.hbase.replication.ReplicationException; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +import org.apache.hadoop.hbase.shaded.protobuf.generated.MasterProcedureProtos.PeerModificationState; + +@Category({ MasterTests.class, LargeTests.class }) +public class TestModifyPeerProcedureRetryBackoff { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestModifyPeerProcedureRetryBackoff.class); + + private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); + + private static boolean FAIL = true; + + public static class TestModifyPeerProcedure extends ModifyPeerProcedure { + + public TestModifyPeerProcedure() { + } + + public TestModifyPeerProcedure(String peerId) { + super(peerId); + } + + @Override + public PeerOperationType getPeerOperationType() { + return PeerOperationType.ADD; + } + + private void tryFail() throws ReplicationException { + synchronized (TestModifyPeerProcedureRetryBackoff.class) { + if (FAIL) { + throw new ReplicationException("Inject error"); + } + FAIL = true; + } + } + + @Override + protected > void addChildProcedure( + @SuppressWarnings("unchecked") T... subProcedure) { + // Make it a no-op + } + + @Override + protected PeerModificationState nextStateAfterRefresh() { + return PeerModificationState.SERIAL_PEER_REOPEN_REGIONS; + } + + @Override + protected boolean enablePeerBeforeFinish() { + return true; + } + + @Override + protected void updateLastPushedSequenceIdForSerialPeer(MasterProcedureEnv env) + throws IOException, ReplicationException { + tryFail(); + } + + @Override + protected void reopenRegions(MasterProcedureEnv env) throws IOException { + try { + tryFail(); + } catch (ReplicationException e) { + throw new IOException(e); + } + } + + @Override + protected void enablePeer(MasterProcedureEnv env) throws ReplicationException { + tryFail(); + } + + @Override + protected void prePeerModification(MasterProcedureEnv env) + throws IOException, ReplicationException { + tryFail(); + } + + @Override + protected void updatePeerStorage(MasterProcedureEnv env) throws ReplicationException { + tryFail(); + } + + @Override + protected void postPeerModification(MasterProcedureEnv env) + throws IOException, ReplicationException { + tryFail(); + } + } + + @BeforeClass + public static void setUp() throws Exception { + UTIL.startMiniCluster(1); + } + + @AfterClass + public static void tearDown() throws Exception { + UTIL.shutdownMiniCluster(); + } + + private void assertBackoffIncrease() throws IOException, InterruptedException { + ProcedureTestUtil.waitUntilProcedureWaitingTimeout(UTIL, TestModifyPeerProcedure.class, 30000); + ProcedureTestUtil.waitUntilProcedureTimeoutIncrease(UTIL, TestModifyPeerProcedure.class, 2); + synchronized (TestModifyPeerProcedureRetryBackoff.class) { + FAIL = false; + } + UTIL.waitFor(30000, () -> FAIL); + } + + @Test + public void test() throws IOException, InterruptedException { + ProcedureExecutor procExec = + UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor(); + long procId = procExec.submitProcedure(new TestModifyPeerProcedure("1")); + // PRE_PEER_MODIFICATION + assertBackoffIncrease(); + // UPDATE_PEER_STORAGE + assertBackoffIncrease(); + // No retry for REFRESH_PEER_ON_RS + // SERIAL_PEER_REOPEN_REGIONS + assertBackoffIncrease(); + // SERIAL_PEER_UPDATE_LAST_PUSHED_SEQ_ID + assertBackoffIncrease(); + // SERIAL_PEER_SET_PEER_ENABLED + assertBackoffIncrease(); + // No retry for SERIAL_PEER_ENABLE_PEER_REFRESH_PEER_ON_RS + // POST_PEER_MODIFICATION + assertBackoffIncrease(); + UTIL.waitFor(30000, () -> procExec.isFinished(procId)); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/replication/TestTransitPeerSyncReplicationStateProcedureBackoff.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/replication/TestTransitPeerSyncReplicationStateProcedureBackoff.java new file mode 100644 index 000000000000..0526a8e8da39 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/replication/TestTransitPeerSyncReplicationStateProcedureBackoff.java @@ -0,0 +1,172 @@ +/** + * 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.replication; + +import java.io.IOException; + +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.ProcedureTestUtil; +import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv; +import org.apache.hadoop.hbase.procedure2.Procedure; +import org.apache.hadoop.hbase.procedure2.ProcedureExecutor; +import org.apache.hadoop.hbase.replication.ReplicationException; +import org.apache.hadoop.hbase.replication.SyncReplicationState; +import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.apache.hadoop.hbase.testclassification.MasterTests; +import org.junit.AfterClass; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; + +@Category({ MasterTests.class, LargeTests.class }) +public class TestTransitPeerSyncReplicationStateProcedureBackoff { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestTransitPeerSyncReplicationStateProcedureBackoff.class); + + private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); + + private static boolean FAIL = true; + + public static class TestTransitPeerSyncReplicationStateProcedure + extends TransitPeerSyncReplicationStateProcedure { + + public TestTransitPeerSyncReplicationStateProcedure() { + } + + public TestTransitPeerSyncReplicationStateProcedure(String peerId, SyncReplicationState state) { + super(peerId, state); + } + + private void tryFail() throws ReplicationException { + synchronized (TestTransitPeerSyncReplicationStateProcedureBackoff.class) { + if (FAIL) { + throw new ReplicationException("Inject error"); + } + FAIL = true; + } + } + + @Override + protected > void addChildProcedure( + @SuppressWarnings("unchecked") T... subProcedure) { + // Make it a no-op + } + + @Override + protected void preTransit(MasterProcedureEnv env) throws IOException { + fromState = SyncReplicationState.DOWNGRADE_ACTIVE; + } + + @Override + protected void setPeerNewSyncReplicationState(MasterProcedureEnv env) + throws ReplicationException { + tryFail(); + } + + @Override + protected void removeAllReplicationQueues(MasterProcedureEnv env) throws ReplicationException { + tryFail(); + } + + @Override + protected void reopenRegions(MasterProcedureEnv env) { + // do nothing; + } + + @Override + protected void transitPeerSyncReplicationState(MasterProcedureEnv env) + throws ReplicationException { + tryFail(); + } + + @Override + protected void createDirForRemoteWAL(MasterProcedureEnv env) throws IOException { + try { + tryFail(); + } catch (ReplicationException e) { + throw new IOException(e); + } + } + } + + @BeforeClass + public static void setUp() throws Exception { + UTIL.startMiniCluster(1); + } + + @AfterClass + public static void tearDown() throws Exception { + UTIL.shutdownMiniCluster(); + } + + private void assertBackoffIncrease() throws IOException, InterruptedException { + ProcedureTestUtil.waitUntilProcedureWaitingTimeout(UTIL, + TestTransitPeerSyncReplicationStateProcedure.class, 30000); + ProcedureTestUtil.waitUntilProcedureTimeoutIncrease(UTIL, + TestTransitPeerSyncReplicationStateProcedure.class, 2); + synchronized (TestTransitPeerSyncReplicationStateProcedure.class) { + FAIL = false; + } + UTIL.waitFor(30000, () -> FAIL); + } + + @Test + public void testDowngradeActiveToActive() throws IOException, InterruptedException { + ProcedureExecutor procExec = + UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor(); + // Test procedure: DOWNGRADE_ACTIVE ==> ACTIVE + long procId = procExec.submitProcedure( + new TestTransitPeerSyncReplicationStateProcedure("1", SyncReplicationState.ACTIVE)); + // No retry for PRE_PEER_SYNC_REPLICATION_STATE_TRANSITION + // SET_PEER_NEW_SYNC_REPLICATION_STATE + assertBackoffIncrease(); + // No retry for REFRESH_PEER_SYNC_REPLICATION_STATE_ON_RS_BEGIN + // No retry for REOPEN_ALL_REGIONS_IN_PEER + // TRANSIT_PEER_NEW_SYNC_REPLICATION_STATE + assertBackoffIncrease(); + // No retry for REFRESH_PEER_SYNC_REPLICATION_STATE_ON_RS_END + // No retry for POST_PEER_SYNC_REPLICATION_STATE_TRANSITION + UTIL.waitFor(30000, () -> procExec.isFinished(procId)); + } + + @Test + public void testDowngradeActiveToStandby() throws IOException, InterruptedException { + ProcedureExecutor procExec = + UTIL.getMiniHBaseCluster().getMaster().getMasterProcedureExecutor(); + // Test procedure: DOWNGRADE_ACTIVE ==> ACTIVE + long procId = procExec.submitProcedure( + new TestTransitPeerSyncReplicationStateProcedure("2", SyncReplicationState.STANDBY)); + // No retry for PRE_PEER_SYNC_REPLICATION_STATE_TRANSITION + // SET_PEER_NEW_SYNC_REPLICATION_STATE + assertBackoffIncrease(); + // No retry for REFRESH_PEER_SYNC_REPLICATION_STATE_ON_RS_BEGIN + // REMOVE_ALL_REPLICATION_QUEUES_IN_PEER + assertBackoffIncrease(); + // TRANSIT_PEER_NEW_SYNC_REPLICATION_STATE + assertBackoffIncrease(); + // No retry for REFRESH_PEER_SYNC_REPLICATION_STATE_ON_RS_END + // CREATE_DIR_FOR_REMOTE_WAL + assertBackoffIncrease(); + // No retry for POST_PEER_SYNC_REPLICATION_STATE_TRANSITION + UTIL.waitFor(30000, () -> procExec.isFinished(procId)); + } +} \ No newline at end of file diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/snapshot/TestSnapshotFileCache.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/snapshot/TestSnapshotFileCache.java index e83dfa718383..22d2734f538c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/snapshot/TestSnapshotFileCache.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/snapshot/TestSnapshotFileCache.java @@ -68,7 +68,6 @@ public class TestSnapshotFileCache { private static final Logger LOG = LoggerFactory.getLogger(TestSnapshotFileCache.class); private static final HBaseTestingUtility UTIL = new HBaseTestingUtility(); - private static long sequenceId = 0; private static FileSystem fs; private static Path rootDir; @@ -163,9 +162,6 @@ List getSnapshotsInProgress(final SnapshotManager snapshotManager) SnapshotMock.SnapshotBuilder complete = createAndTestSnapshotV1(cache, "snapshot", false, false); - SnapshotMock.SnapshotBuilder inProgress = - createAndTestSnapshotV1(cache, "snapshotInProgress", true, false); - int countBeforeCheck = count.get(); FSUtils.logFileSystemState(fs, rootDir, LOG); @@ -238,12 +234,11 @@ private void createAndTestSnapshot(final SnapshotFileCache cache, List files = new ArrayList<>(); for (int i = 0; i < 3; ++i) { for (Path filePath: builder.addRegion()) { - String fileName = filePath.getName(); if (tmp) { // We should be able to find all the files while the snapshot creation is in-progress FSUtils.logFileSystemState(fs, rootDir, LOG); - Iterable nonSnapshot = getNonSnapshotFiles(cache, filePath); - assertFalse("Cache didn't find " + fileName, Iterables.contains(nonSnapshot, fileName)); + assertFalse("Cache didn't find " + filePath, + contains(getNonSnapshotFiles(cache, filePath), filePath)); } files.add(filePath); } @@ -256,9 +251,7 @@ private void createAndTestSnapshot(final SnapshotFileCache cache, // Make sure that all files are still present for (Path path: files) { - Iterable nonSnapshotFiles = getNonSnapshotFiles(cache, path); - assertFalse("Cache didn't find " + path.getName(), - Iterables.contains(nonSnapshotFiles, path.getName())); + assertFalse("Cache didn't find " + path, contains(getNonSnapshotFiles(cache, path), path)); } FSUtils.logFileSystemState(fs, rootDir, LOG); @@ -267,25 +260,28 @@ private void createAndTestSnapshot(final SnapshotFileCache cache, fs.delete(builder.getSnapshotsDir(), true); FSUtils.logFileSystemState(fs, rootDir, LOG); - // The files should be in cache until next refresh - for (Path filePath: files) { - Iterable nonSnapshotFiles = getNonSnapshotFiles(cache, filePath); - assertFalse("Cache didn't find " + filePath.getName(), Iterables.contains(nonSnapshotFiles, - filePath.getName())); - } - // then trigger a refresh cache.triggerCacheRefreshForTesting(); // and not it shouldn't find those files for (Path filePath: files) { - Iterable nonSnapshotFiles = getNonSnapshotFiles(cache, filePath); - assertTrue("Cache found '" + filePath.getName() + "', but it shouldn't have.", - !Iterables.contains(nonSnapshotFiles, filePath.getName())); + assertTrue("Cache found '" + filePath + "', but it shouldn't have.", + contains(getNonSnapshotFiles(cache, filePath), filePath)); + + } + } + } + + private static boolean contains(Iterable files, Path filePath) { + for (FileStatus status: files) { + LOG.debug("debug in contains, 3.1: " + status.getPath() + " filePath:" + filePath); + if (filePath.equals(status.getPath())) { + return true; } } + return false; } - private Iterable getNonSnapshotFiles(SnapshotFileCache cache, Path storeFile) + private static Iterable getNonSnapshotFiles(SnapshotFileCache cache, Path storeFile) throws IOException { return cache.getUnreferencedFiles( Arrays.asList(FSUtils.listStatus(fs, storeFile.getParent())), null diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/MobTestUtil.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/MobTestUtil.java index 76cb6645966d..8972dba58e83 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/MobTestUtil.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/MobTestUtil.java @@ -24,6 +24,7 @@ import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellUtil; +import org.apache.hadoop.hbase.HBaseTestingUtility; import org.apache.hadoop.hbase.KeyValue; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.ResultScanner; @@ -104,4 +105,16 @@ public static void assertCellsValue(Table table, Scan scan, results.close(); Assert.assertEquals(expectedCount, count); } + + /** + * Gets the number of rows in the given table. + * @param table to get the scanner + * @return the number of rows + */ + public static int countMobRows(final Table table) throws IOException { + Scan scan = new Scan(); + // Do not retrieve the mob data when scanning + scan.setAttribute(MobConstants.MOB_SCAN_RAW, Bytes.toBytes(Boolean.TRUE)); + return HBaseTestingUtility.countRows(table, scan); + } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/compactions/TestMobCompactor.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/compactions/TestMobCompactor.java index 8ed4fbb15565..86e07d2d4066 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/compactions/TestMobCompactor.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/mob/compactions/TestMobCompactor.java @@ -78,6 +78,7 @@ import org.apache.hadoop.hbase.master.cleaner.TimeToLiveHFileCleaner; import org.apache.hadoop.hbase.mob.MobConstants; import org.apache.hadoop.hbase.mob.MobFileName; +import org.apache.hadoop.hbase.mob.MobTestUtil; import org.apache.hadoop.hbase.mob.MobUtils; import org.apache.hadoop.hbase.regionserver.BloomType; import org.apache.hadoop.hbase.regionserver.HRegion; @@ -295,7 +296,7 @@ public void testMinorCompaction() throws Exception { int rowNumPerRegion = count * rowNumPerFile; assertEquals("Before deleting: mob rows count", regionNum * rowNumPerRegion, - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("Before deleting: mob cells count", regionNum * cellNumPerRow * rowNumPerRegion, countMobCells(table)); assertEquals("Before deleting: mob file count", regionNum * count, @@ -305,7 +306,7 @@ public void testMinorCompaction() throws Exception { createDelFile(table, tableName, Bytes.toBytes(family1), Bytes.toBytes(qf1)); assertEquals("Before compaction: mob rows count", regionNum * (rowNumPerRegion - delRowNum), - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("Before compaction: mob cells count", regionNum * (cellNumPerRow * rowNumPerRegion - delCellNum), countMobCells(table)); assertEquals("Before compaction: family1 mob file count", regionNum * count, @@ -322,7 +323,7 @@ public void testMinorCompaction() throws Exception { compactor.compact(); assertEquals("After compaction: mob rows count", regionNum * (rowNumPerRegion - delRowNum), - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("After compaction: mob cells count", regionNum * (cellNumPerRow * rowNumPerRegion - delCellNum), countMobCells(table)); // After the compaction, the files smaller than the mob compaction merge size @@ -445,7 +446,7 @@ public void testCompactionWithHFileLink() throws IOException, InterruptedExcepti createDelFile(table, tableName, Bytes.toBytes(family1), Bytes.toBytes(qf1)); assertEquals("Before compaction: mob rows count", regionNum * (rowNumPerRegion - delRowNum), - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("Before compaction: mob cells count", regionNum * (cellNumPerRow * rowNumPerRegion - delCellNum), countMobCells(table)); assertEquals("Before compaction: family1 mob file count", regionNum * count, @@ -462,7 +463,7 @@ public void testCompactionWithHFileLink() throws IOException, InterruptedExcepti compactor.compact(); assertEquals("After first compaction: mob rows count", regionNum - * (rowNumPerRegion - delRowNum), countMobRows(table)); + * (rowNumPerRegion - delRowNum), MobTestUtil.countMobRows(table)); assertEquals("After first compaction: mob cells count", regionNum * (cellNumPerRow * rowNumPerRegion - delCellNum), countMobCells(table)); assertEquals("After first compaction: family1 mob file count", regionNum, @@ -482,7 +483,7 @@ public void testCompactionWithHFileLink() throws IOException, InterruptedExcepti admin.enableTable(tableName); assertEquals("After restoring snapshot: mob rows count", regionNum * rowNumPerRegion, - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("After restoring snapshot: mob cells count", regionNum * cellNumPerRow * rowNumPerRegion, countMobCells(table)); assertEquals("After restoring snapshot: family1 mob file count", regionNum * count, @@ -500,7 +501,7 @@ public void testCompactionWithHFileLink() throws IOException, InterruptedExcepti compactor.compact(); assertEquals("After second compaction: mob rows count", regionNum * rowNumPerRegion, - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("After second compaction: mob cells count", regionNum * cellNumPerRow * rowNumPerRegion, countMobCells(table)); assertEquals("After second compaction: family1 mob file count", regionNum, @@ -550,7 +551,7 @@ public void testMajorCompactionFromAdmin() throws Exception { int rowNumPerRegion = count * rowNumPerFile; assertEquals("Before deleting: mob rows count", regionNum * rowNumPerRegion, - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("Before deleting: mob cells count", regionNum * cellNumPerRow * rowNumPerRegion, countMobCells(table)); assertEquals("Before deleting: mob file count", regionNum * count, @@ -559,7 +560,7 @@ public void testMajorCompactionFromAdmin() throws Exception { createDelFile(table, tableName, Bytes.toBytes(family1), Bytes.toBytes(qf1)); assertEquals("Before compaction: mob rows count", regionNum * (rowNumPerRegion - delRowNum), - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("Before compaction: mob cells count", regionNum * (cellNumPerRow * rowNumPerRegion - delCellNum), countMobCells(table)); assertEquals("Before compaction: family1 mob file count", regionNum * count, @@ -576,7 +577,7 @@ public void testMajorCompactionFromAdmin() throws Exception { waitUntilMobCompactionFinished(tableName); assertEquals("After compaction: mob rows count", regionNum * (rowNumPerRegion - delRowNum), - countMobRows(table)); + MobTestUtil.countMobRows(table)); assertEquals("After compaction: mob cells count", regionNum * (cellNumPerRow * rowNumPerRegion - delCellNum), countMobCells(table)); assertEquals("After compaction: family1 mob file count", regionNum, @@ -763,18 +764,6 @@ private void waitUntilMobCompactionFinished(TableName tableName) throws IOExcept assertEquals(CompactionState.NONE, state); } - /** - * Gets the number of rows in the given table. - * @param table to get the scanner - * @return the number of rows - */ - private int countMobRows(final Table table) throws IOException { - Scan scan = new Scan(); - // Do not retrieve the mob data when scanning - scan.setAttribute(MobConstants.MOB_SCAN_RAW, Bytes.toBytes(Boolean.TRUE)); - return TEST_UTIL.countRows(table, scan); - } - /** * Gets the number of cells in the given table. * @param table to get the scanner @@ -923,13 +912,15 @@ private void loadDataForPartitionPolicy(Admin admin, BufferedMutator table, Tabl for (int i = 0; i < 1000; i ++) { Put put0 = new Put(Bytes.toBytes("r0" + i)); - put0.addColumn(Bytes.toBytes(family1), Bytes.toBytes(qf1), tsFor20151130Monday, Bytes.toBytes(mobValue0)); + put0.addColumn(Bytes.toBytes(family1), Bytes.toBytes(qf1), + tsFor20151130Monday, Bytes.toBytes(mobValue0)); pArray[i] = put0; } loadData(admin, bufMut, tableName, pArray); Put put06 = new Put(mobKey06); - put06.addColumn(Bytes.toBytes(family1), Bytes.toBytes(qf1), tsFor20151128Saturday, Bytes.toBytes(mobValue0)); + put06.addColumn(Bytes.toBytes(family1), Bytes.toBytes(qf1), + tsFor20151128Saturday, Bytes.toBytes(mobValue0)); loadData(admin, bufMut, tableName, new Put[] { put06 }); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/CreateRandomStoreFile.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/CreateRandomStoreFile.java index aa3acc43466a..8a512e62dfcb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/CreateRandomStoreFile.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/CreateRandomStoreFile.java @@ -34,6 +34,7 @@ import org.apache.hadoop.hbase.io.hfile.HFileContext; import org.apache.hadoop.hbase.io.hfile.HFileContextBuilder; import org.apache.hadoop.hbase.util.BloomFilterFactory; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.io.BytesWritable; import org.slf4j.Logger; import org.slf4j.LoggerFactory; @@ -64,6 +65,7 @@ public class CreateRandomStoreFile { private static final String VALUE_SIZE_OPTION = "v"; private static final String COMPRESSION_OPTION = "c"; private static final String BLOOM_FILTER_OPTION = "bf"; + private static final String BLOOM_FILTER_PARAM_OPTION = "bfp"; private static final String BLOCK_SIZE_OPTION = "bs"; private static final String BLOOM_BLOCK_SIZE_OPTION = "bfbs"; private static final String INDEX_BLOCK_SIZE_OPTION = "ibs"; @@ -103,6 +105,8 @@ public boolean run(String[] args) throws IOException { options.addOption(BLOOM_FILTER_OPTION, "bloom_filter", true, "Bloom filter type, one of " + Arrays.toString(BloomType.values())); + options.addOption(BLOOM_FILTER_PARAM_OPTION, "bloom_param", true, + "the parameter of the bloom filter"); options.addOption(BLOCK_SIZE_OPTION, "block_size", true, "HFile block size"); options.addOption(BLOOM_BLOCK_SIZE_OPTION, "bloom_block_size", true, @@ -169,6 +173,25 @@ public boolean run(String[] args) throws IOException { BLOOM_FILTER_OPTION)); } + if (bloomType == BloomType.ROWPREFIX_FIXED_LENGTH) { + if (!cmdLine.hasOption(BLOOM_FILTER_PARAM_OPTION)) { + LOG.error("the parameter of bloom filter is not specified"); + return false; + } else { + conf.set(BloomFilterUtil.PREFIX_LENGTH_KEY, + cmdLine.getOptionValue(BLOOM_FILTER_PARAM_OPTION)); + } + } + + if (bloomType == BloomType.ROWPREFIX_DELIMITED) { + if (!cmdLine.hasOption(BLOOM_FILTER_PARAM_OPTION)) { + LOG.error("the parameter of bloom filter is not specified"); + return false; + } else { + conf.set(BloomFilterUtil.DELIMITER_KEY, cmdLine.getOptionValue(BLOOM_FILTER_PARAM_OPTION)); + } + } + int blockSize = HConstants.DEFAULT_BLOCKSIZE; if (cmdLine.hasOption(BLOCK_SIZE_OPTION)) blockSize = Integer.valueOf(cmdLine.getOptionValue(BLOCK_SIZE_OPTION)); @@ -209,7 +232,7 @@ public boolean run(String[] args) throws IOException { Path storeFilePath = sfw.getPath(); long fileSize = fs.getFileStatus(storeFilePath).getLen(); - LOG.info("Created " + storeFilePath + ", " + fileSize + " bytes"); + LOG.info("Created {}, {} bytes, compression={}", storeFilePath, fileSize, compr.toString()); return true; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEndToEndSplitTransaction.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEndToEndSplitTransaction.java index 85e9d3098d52..1418d6e74fb4 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEndToEndSplitTransaction.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEndToEndSplitTransaction.java @@ -296,7 +296,7 @@ static class RegionChecker extends ScheduledChore { Throwable ex; RegionChecker(Configuration conf, Stoppable stopper, TableName tableName) throws IOException { - super("RegionChecker", stopper, 10); + super("RegionChecker", stopper, 100); this.conf = conf; this.tableName = tableName; @@ -509,7 +509,7 @@ public static void blockUntilRegionIsInMeta(Connection conn, long timeout, Regio log("found region in META: " + hri.getRegionNameAsString()); break; } - Threads.sleep(10); + Threads.sleep(100); } } @@ -532,7 +532,7 @@ public static void blockUntilRegionIsOpened(Configuration conf, long timeout, Re } catch (IOException ex) { // wait some more } - Threads.sleep(10); + Threads.sleep(100); } } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java index 024ca36e2cca..b2d9a1bff29c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegion.java @@ -705,7 +705,7 @@ public void testSkipRecoveredEditsReplay() throws Exception { for (HStore store : region.getStores()) { maxSeqIdInStores.put(Bytes.toBytes(store.getColumnFamilyName()), minSeqId - 1); } - long seqId = region.replayRecoveredEditsIfAny(regiondir, maxSeqIdInStores, null, status); + long seqId = region.replayRecoveredEditsIfAny(maxSeqIdInStores, null, status); assertEquals(maxSeqId, seqId); region.getMVCC().advanceTo(seqId); Get get = new Get(row); @@ -757,7 +757,7 @@ public void testSkipRecoveredEditsReplaySomeIgnored() throws Exception { for (HStore store : region.getStores()) { maxSeqIdInStores.put(Bytes.toBytes(store.getColumnFamilyName()), recoverSeqId - 1); } - long seqId = region.replayRecoveredEditsIfAny(regiondir, maxSeqIdInStores, null, status); + long seqId = region.replayRecoveredEditsIfAny(maxSeqIdInStores, null, status); assertEquals(maxSeqId, seqId); region.getMVCC().advanceTo(seqId); Get get = new Get(row); @@ -801,7 +801,7 @@ public void testSkipRecoveredEditsReplayAllIgnored() throws Exception { for (HStore store : region.getStores()) { maxSeqIdInStores.put(Bytes.toBytes(store.getColumnFamilyName()), minSeqId); } - long seqId = region.replayRecoveredEditsIfAny(regiondir, maxSeqIdInStores, null, null); + long seqId = region.replayRecoveredEditsIfAny(maxSeqIdInStores, null, null); assertEquals(minSeqId, seqId); } @@ -855,7 +855,7 @@ public void testSkipRecoveredEditsReplayTheLastFileIgnored() throws Exception { for (HStore store : region.getStores()) { maxSeqIdInStores.put(Bytes.toBytes(store.getColumnFamilyName()), recoverSeqId - 1); } - long seqId = region.replayRecoveredEditsIfAny(regiondir, maxSeqIdInStores, null, status); + long seqId = region.replayRecoveredEditsIfAny(maxSeqIdInStores, null, status); assertEquals(maxSeqId, seqId); // assert that the files are flushed @@ -5533,6 +5533,46 @@ public void testReverseScanShouldNotScanMemstoreIfReadPtLesser() throws Exceptio currRow.get(1).getRowOffset(), currRow.get(1).getRowLength())); } + @Test + public void testReverseScanWhenPutCellsAfterOpenReverseScan() throws Exception { + byte[] cf1 = Bytes.toBytes("CF1"); + byte[][] families = { cf1 }; + byte[] col = Bytes.toBytes("C"); + + HBaseConfiguration conf = new HBaseConfiguration(); + this.region = initHRegion(tableName, method, conf, families); + + Put put = new Put(Bytes.toBytes("199996")); + put.addColumn(cf1, col, Bytes.toBytes("val")); + region.put(put); + Put put2 = new Put(Bytes.toBytes("199995")); + put2.addColumn(cf1, col, Bytes.toBytes("val")); + region.put(put2); + + // Create a reverse scan + Scan scan = new Scan(Bytes.toBytes("199996")); + scan.setReversed(true); + RegionScannerImpl scanner = region.getScanner(scan); + + // Put a lot of cells that have sequenceIDs grater than the readPt of the reverse scan + for (int i = 100000; i < 200000; i++) { + Put p = new Put(Bytes.toBytes("" + i)); + p.addColumn(cf1, col, Bytes.toBytes("" + i)); + region.put(p); + } + List currRow = new ArrayList<>(); + boolean hasNext; + do { + hasNext = scanner.next(currRow); + } while (hasNext); + + assertEquals(2, currRow.size()); + assertEquals("199996", Bytes.toString(currRow.get(0).getRowArray(), + currRow.get(0).getRowOffset(), currRow.get(0).getRowLength())); + assertEquals("199995", Bytes.toString(currRow.get(1).getRowArray(), + currRow.get(1).getRowOffset(), currRow.get(1).getRowLength())); + } + @Test public void testWriteRequestsCounter() throws IOException { byte[] fam = Bytes.toBytes("info"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java index 5cd0403f5d02..4b8f5f200fba 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHStoreFile.java @@ -748,7 +748,7 @@ public void testBloomTypes() throws Exception { reader.loadFileInfo(); reader.loadBloomfilter(); StoreFileScanner scanner = getStoreFileScanner(reader, false, false); - assertEquals(expKeys[x], reader.generalBloomFilter.getKeyCount()); + assertEquals(expKeys[x], reader.getGeneralBloomFilter().getKeyCount()); HStore store = mock(HStore.class); when(store.getColumnFamilyDescriptor()) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHeapMemoryManager.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHeapMemoryManager.java index 41bfd48c0ad4..9f05a73f6f6e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHeapMemoryManager.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHeapMemoryManager.java @@ -758,14 +758,15 @@ public MemstoreFlusherStub(long memstoreSize) { } @Override - public void requestFlush(HRegion region, boolean forceFlushAllStores, + public boolean requestFlush(HRegion region, boolean forceFlushAllStores, FlushLifeCycleTracker tracker) { this.listener.flushRequested(flushType, region); + return true; } @Override - public void requestDelayedFlush(HRegion region, long delay, boolean forceFlushAllStores) { - + public boolean requestDelayedFlush(HRegion region, long delay, boolean forceFlushAllStores) { + return true; } @Override diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMultiColumnScanner.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMultiColumnScanner.java index 20d28b3e4e3e..2ff0d8c24a57 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMultiColumnScanner.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMultiColumnScanner.java @@ -49,6 +49,7 @@ import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.RegionServerTests; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.Bytes; import org.junit.ClassRule; import org.junit.Test; @@ -150,6 +151,8 @@ public TestMultiColumnScanner(Compression.Algorithm comprAlgo, @Test public void testMultiColumnScanner() throws IOException { + TEST_UTIL.getConfiguration().setInt(BloomFilterUtil.PREFIX_LENGTH_KEY, 10); + TEST_UTIL.getConfiguration().set(BloomFilterUtil.DELIMITER_KEY, "#"); HRegion region = TEST_UTIL.createTestRegion(TABLE_NAME, new HColumnDescriptor(FAMILY) .setCompressionType(comprAlgo) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java index 5754edbc9a73..79ee15dba6d9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerMetrics.java @@ -112,6 +112,7 @@ public static void startCluster() throws Exception { // testMobMetrics creates few hfiles and manages compaction manually. conf.setInt("hbase.hstore.compactionThreshold", 100); conf.setInt("hbase.hstore.compaction.max", 100); + conf.setInt("hbase.regionserver.periodicmemstoreflusher.rangeofdelayseconds", 4*60); conf.setInt(HConstants.REGIONSERVER_INFO_PORT, -1); TEST_UTIL.startMiniCluster(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerReportForDuty.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerReportForDuty.java index 83632be67895..aaf2d2eb9a04 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerReportForDuty.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerReportForDuty.java @@ -21,6 +21,9 @@ import static org.junit.Assert.assertTrue; import java.io.IOException; +import java.io.StringWriter; + +import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.HBaseTestingUtility; @@ -28,11 +31,17 @@ import org.apache.hadoop.hbase.LocalHBaseCluster; import org.apache.hadoop.hbase.MiniHBaseCluster.MiniHBaseClusterRegionServer; import org.apache.hadoop.hbase.ServerName; +import org.apache.hadoop.hbase.ipc.ServerNotRunningYetException; +import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.LoadBalancer; import org.apache.hadoop.hbase.master.ServerManager; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.JVMClusterUtil.MasterThread; import org.apache.hadoop.hbase.util.JVMClusterUtil.RegionServerThread; +import org.apache.log4j.Appender; +import org.apache.log4j.Layout; +import org.apache.log4j.PatternLayout; +import org.apache.log4j.WriterAppender; import org.apache.zookeeper.KeeperException; import org.junit.After; import org.junit.Before; @@ -77,6 +86,85 @@ public void tearDown() throws Exception { testUtil.shutdownMiniDFSCluster(); } + /** + * LogCapturer is similar to {@link org.apache.hadoop.test.GenericTestUtils.LogCapturer} + * except that this implementation has a default appender to the root logger. + * Hadoop 2.8+ supports the default appender in the LogCapture it ships and this can be replaced. + * TODO: This class can be removed after we upgrade Hadoop dependency. + */ + static class LogCapturer { + private StringWriter sw = new StringWriter(); + private WriterAppender appender; + private org.apache.log4j.Logger logger; + + LogCapturer(org.apache.log4j.Logger logger) { + this.logger = logger; + Appender defaultAppender = org.apache.log4j.Logger.getRootLogger().getAppender("stdout"); + if (defaultAppender == null) { + defaultAppender = org.apache.log4j.Logger.getRootLogger().getAppender("console"); + } + final Layout layout = (defaultAppender == null) ? new PatternLayout() : + defaultAppender.getLayout(); + this.appender = new WriterAppender(layout, sw); + this.logger.addAppender(this.appender); + } + + String getOutput() { + return sw.toString(); + } + + public void stopCapturing() { + this.logger.removeAppender(this.appender); + } + } + + /** + * This test HMaster class will always throw ServerNotRunningYetException if checked. + */ + public static class NeverInitializedMaster extends HMaster { + public NeverInitializedMaster(Configuration conf) throws IOException, KeeperException { + super(conf); + } + + @Override + protected void checkServiceStarted() throws ServerNotRunningYetException { + throw new ServerNotRunningYetException("Server is not running yet"); + } + } + + /** + * Tests region server should backoff to report for duty if master is not ready. + */ + @Test + public void testReportForDutyBackoff() throws IOException, InterruptedException { + cluster.getConfiguration().set(HConstants.MASTER_IMPL, NeverInitializedMaster.class.getName()); + master = cluster.addMaster(); + master.start(); + + LogCapturer capturer = new LogCapturer(org.apache.log4j.Logger.getLogger(HRegionServer.class)); + // Set sleep interval relatively low so that exponential backoff is more demanding. + int msginterval = 100; + cluster.getConfiguration().setInt("hbase.regionserver.msginterval", msginterval); + rs = cluster.addRegionServer(); + rs.start(); + + int interval = 10_000; + Thread.sleep(interval); + capturer.stopCapturing(); + String output = capturer.getOutput(); + LOG.info("{}", output); + String failMsg = "reportForDuty failed;"; + int count = StringUtils.countMatches(output, failMsg); + + // Following asserts the actual retry number is in range (expectedRetry/2, expectedRetry*2). + // Ideally we can assert the exact retry count. We relax here to tolerate contention error. + int expectedRetry = (int)Math.ceil(Math.log(interval - msginterval)); + assertTrue(String.format("reportForDuty retries %d times, less than expected min %d", + count, expectedRetry / 2), count > expectedRetry / 2); + assertTrue(String.format("reportForDuty retries %d times, more than expected max %d", + count, expectedRetry * 2), count < expectedRetry * 2); + } + /** * Tests region sever reportForDuty with backup master becomes primary master after * the first master goes away. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowPrefixBloomFilter.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowPrefixBloomFilter.java new file mode 100644 index 000000000000..61de21f44d08 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowPrefixBloomFilter.java @@ -0,0 +1,399 @@ +/** + * 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.regionserver; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertTrue; +import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.when; + +import java.io.IOException; +import java.util.concurrent.atomic.AtomicInteger; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.FileSystem; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.KeyValue; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; +import org.apache.hadoop.hbase.client.Get; +import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.io.hfile.CacheConfig; +import org.apache.hadoop.hbase.io.hfile.HFileContext; +import org.apache.hadoop.hbase.io.hfile.HFileContextBuilder; +import org.apache.hadoop.hbase.log.HBaseMarkers; +import org.apache.hadoop.hbase.testclassification.RegionServerTests; +import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.apache.hadoop.hbase.util.BloomFilterFactory; +import org.apache.hadoop.hbase.util.BloomFilterUtil; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.ChecksumType; +import org.apache.hadoop.hbase.util.FSUtils; +import org.junit.After; +import org.junit.Before; +import org.junit.ClassRule; +import org.junit.Rule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.junit.rules.TestName; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; + +/** + * Test TestRowPrefixBloomFilter + */ +@Category({RegionServerTests.class, SmallTests.class}) +public class TestRowPrefixBloomFilter { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestRowPrefixBloomFilter.class); + + private static final Logger LOG = LoggerFactory.getLogger(TestRowPrefixBloomFilter.class); + private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); + private CacheConfig cacheConf = new CacheConfig(TEST_UTIL.getConfiguration()); + private static final ChecksumType CKTYPE = ChecksumType.CRC32C; + private static final int CKBYTES = 512; + private boolean localfs = false; + private static Configuration conf; + private static FileSystem fs; + private static Path testDir; + private static final int BLOCKSIZE_SMALL = 8192; + private static final float err = (float) 0.01; + private static final int prefixLength = 10; + private static final String delimiter = "#"; + private static final String invalidFormatter = "%08d"; + private static final String prefixFormatter = "%010d"; + private static final String suffixFormatter = "%010d"; + + @Rule + public TestName name = new TestName(); + + @Before + public void setUp() throws Exception { + conf = TEST_UTIL.getConfiguration(); + conf.setFloat(BloomFilterFactory.IO_STOREFILE_BLOOM_ERROR_RATE, err); + conf.setBoolean(BloomFilterFactory.IO_STOREFILE_BLOOM_ENABLED, true); + conf.setInt(BloomFilterUtil.PREFIX_LENGTH_KEY, prefixLength); + conf.set(BloomFilterUtil.DELIMITER_KEY, delimiter); + + localfs = + (conf.get("fs.defaultFS", "file:///").compareTo("file:///") == 0); + + if (fs == null) { + fs = FileSystem.get(conf); + } + try { + if (localfs) { + testDir = TEST_UTIL.getDataTestDir("TestRowPrefixBloomFilter"); + if (fs.exists(testDir)) { + fs.delete(testDir, true); + } + } else { + testDir = FSUtils.getRootDir(conf); + } + } catch (Exception e) { + LOG.error(HBaseMarkers.FATAL, "error during setup", e); + throw e; + } + } + + @After + public void tearDown() throws Exception { + try { + if (localfs) { + if (fs.exists(testDir)) { + fs.delete(testDir, true); + } + } + } catch (Exception e) { + LOG.error(HBaseMarkers.FATAL, "error during tear down", e); + } + } + + private static StoreFileScanner getStoreFileScanner(StoreFileReader reader) { + return reader.getStoreFileScanner(false, false, false, 0, 0, false); + } + + private void writeStoreFile(final Path f, BloomType bt, int expKeys, int prefixRowCount, + int suffixRowCount) throws IOException { + HFileContext meta = new HFileContextBuilder() + .withBlockSize(BLOCKSIZE_SMALL) + .withChecksumType(CKTYPE) + .withBytesPerCheckSum(CKBYTES) + .build(); + // Make a store file and write data to it. + StoreFileWriter writer = new StoreFileWriter.Builder(conf, cacheConf, fs) + .withFilePath(f) + .withBloomType(bt) + .withMaxKeyCount(expKeys) + .withFileContext(meta) + .build(); + long now = System.currentTimeMillis(); + try { + //Put with valid row style + for (int i = 0; i < prefixRowCount; i += 2) { // prefix rows + String prefixRow = String.format(prefixFormatter, i); + for (int j = 0; j < suffixRowCount; j++) { // suffix rows + String row = prefixRow + "#" + String.format(suffixFormatter, j); + KeyValue kv = new KeyValue(Bytes.toBytes(row), Bytes.toBytes("family"), + Bytes.toBytes("col"), now, Bytes.toBytes("value")); + writer.append(kv); + } + } + + //Put with invalid row style + for (int i = prefixRowCount; i < prefixRowCount*2; i += 2) { // prefix rows + String row = String.format(invalidFormatter, i); + KeyValue kv = new KeyValue(Bytes.toBytes(row), Bytes.toBytes("family"), + Bytes.toBytes("col"), now, Bytes.toBytes("value")); + writer.append(kv); + } + } finally { + writer.close(); + } + } + + @Test + public void testRowPrefixBloomFilter() throws Exception { + FileSystem fs = FileSystem.getLocal(conf); + BloomType[] bt = {BloomType.ROWPREFIX_FIXED_LENGTH, BloomType.ROWPREFIX_DELIMITED}; + int prefixRowCount = 50; + int suffixRowCount = 10; + int expKeys = 50; + float expErr = 2*prefixRowCount*suffixRowCount*err; + for (int x : new int[]{0,1}) { + // write the file + Path f = new Path(testDir, name.getMethodName()); + writeStoreFile(f, bt[x], expKeys, prefixRowCount, suffixRowCount); + + // read the file + StoreFileReader reader = new StoreFileReader(fs, f, cacheConf, true, + new AtomicInteger(0), true, conf); + reader.loadFileInfo(); + reader.loadBloomfilter(); + + //check basic param + assertEquals(bt[x], reader.getBloomFilterType()); + if (bt[x] == BloomType.ROWPREFIX_FIXED_LENGTH) { + assertEquals(prefixLength, reader.getPrefixLength()); + assertEquals("null", Bytes.toStringBinary(reader.getDelimiter())); + } else if (bt[x] == BloomType.ROWPREFIX_DELIMITED){ + assertEquals(-1, reader.getPrefixLength()); + assertEquals(delimiter, Bytes.toStringBinary(reader.getDelimiter())); + } + assertEquals(expKeys, reader.getGeneralBloomFilter().getKeyCount()); + StoreFileScanner scanner = getStoreFileScanner(reader); + HStore store = mock(HStore.class); + when(store.getColumnFamilyDescriptor()) + .thenReturn(ColumnFamilyDescriptorBuilder.of("family")); + // check false positives rate + int falsePos = 0; + int falseNeg = 0; + for (int i = 0; i < prefixRowCount; i++) { // prefix rows + String prefixRow = String.format(prefixFormatter, i); + for (int j = 0; j < suffixRowCount; j++) { // suffix rows + String startRow = prefixRow + "#" + String.format(suffixFormatter, j); + String stopRow = prefixRow + "#" + String.format(suffixFormatter, j+1); + Scan scan = new Scan().withStartRow(Bytes.toBytes(startRow)) + .withStopRow(Bytes.toBytes(stopRow)); + boolean exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + boolean shouldPrefixRowExist = i % 2 == 0; + if (shouldPrefixRowExist) { + if (!exists) { + falseNeg++; + } + } else { + if (exists) { + falsePos++; + } + } + } + } + + for (int i = prefixRowCount; i < prefixRowCount * 2; i++) { // prefix rows + String row = String.format(invalidFormatter, i); + Scan scan = new Scan(new Get(Bytes.toBytes(row))); + boolean exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + boolean shouldPrefixRowExist = i % 2 == 0; + if (shouldPrefixRowExist) { + if (!exists) { + falseNeg++; + } + } else { + if (exists) { + falsePos++; + } + } + } + reader.close(true); // evict because we are about to delete the file + fs.delete(f, true); + assertEquals("False negatives: " + falseNeg, 0, falseNeg); + int maxFalsePos = (int) (2 * expErr); + assertTrue("Too many false positives: " + falsePos + + " (err=" + err + ", expected no more than " + maxFalsePos + ")", + falsePos <= maxFalsePos); + } + } + + @Test + public void testRowPrefixBloomFilterWithGet() throws Exception { + FileSystem fs = FileSystem.getLocal(conf); + BloomType[] bt = {BloomType.ROWPREFIX_FIXED_LENGTH, BloomType.ROWPREFIX_DELIMITED}; + int prefixRowCount = 50; + int suffixRowCount = 10; + int expKeys = 50; + for (int x : new int[]{0,1}) { + // write the file + Path f = new Path(testDir, name.getMethodName()); + writeStoreFile(f, bt[x], expKeys, prefixRowCount, suffixRowCount); + + StoreFileReader reader = new StoreFileReader(fs, f, cacheConf, true, + new AtomicInteger(0), true, conf); + reader.loadFileInfo(); + reader.loadBloomfilter(); + + StoreFileScanner scanner = getStoreFileScanner(reader); + HStore store = mock(HStore.class); + when(store.getColumnFamilyDescriptor()) + .thenReturn(ColumnFamilyDescriptorBuilder.of("family")); + + //Get with valid row style + //prefix row in bloom + String prefixRow = String.format(prefixFormatter, prefixRowCount-2); + String row = prefixRow + "#" + String.format(suffixFormatter, 0); + Scan scan = new Scan(new Get(Bytes.toBytes(row))); + boolean exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + + // prefix row not in bloom + prefixRow = String.format(prefixFormatter, prefixRowCount-1); + row = prefixRow + "#" + String.format(suffixFormatter, 0); + scan = new Scan(new Get(Bytes.toBytes(row))); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertFalse(exists); + + // Get with invalid row style + // ROWPREFIX: the length of row is less than prefixLength + // ROWPREFIX_DELIMITED: Row does not contain delimiter + // row in bloom + row = String.format(invalidFormatter, prefixRowCount+2); + scan = new Scan(new Get(Bytes.toBytes(row))); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + + // row not in bloom + row = String.format(invalidFormatter, prefixRowCount+1); + scan = new Scan(new Get(Bytes.toBytes(row))); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertFalse(exists); + + reader.close(true); // evict because we are about to delete the file + fs.delete(f, true); + } + } + + @Test + public void testRowPrefixBloomFilterWithScan() throws Exception { + FileSystem fs = FileSystem.getLocal(conf); + BloomType[] bt = {BloomType.ROWPREFIX_FIXED_LENGTH, BloomType.ROWPREFIX_DELIMITED}; + int prefixRowCount = 50; + int suffixRowCount = 10; + int expKeys = 50; + for (int x : new int[]{0,1}) { + // write the file + Path f = new Path(testDir, name.getMethodName()); + writeStoreFile(f, bt[x], expKeys, prefixRowCount, suffixRowCount); + + StoreFileReader reader = new StoreFileReader(fs, f, cacheConf, true, + new AtomicInteger(0), true, conf); + reader.loadFileInfo(); + reader.loadBloomfilter(); + + StoreFileScanner scanner = getStoreFileScanner(reader); + HStore store = mock(HStore.class); + when(store.getColumnFamilyDescriptor()) + .thenReturn(ColumnFamilyDescriptorBuilder.of("family")); + + //Scan with valid row style. startRow and stopRow have a common prefix. + //And the length of the common prefix is no less than prefixLength. + //prefix row in bloom + String prefixRow = String.format(prefixFormatter, prefixRowCount-2); + String startRow = prefixRow + "#" + String.format(suffixFormatter, 0); + String stopRow = prefixRow + "#" + String.format(suffixFormatter, 1); + Scan scan = new Scan().withStartRow(Bytes.toBytes(startRow)) + .withStopRow(Bytes.toBytes(stopRow)); + boolean exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + + // prefix row not in bloom + prefixRow = String.format(prefixFormatter, prefixRowCount-1); + startRow = prefixRow + "#" + String.format(suffixFormatter, 0); + stopRow = prefixRow + "#" + String.format(suffixFormatter, 1); + scan = new Scan().withStartRow(Bytes.toBytes(startRow)) + .withStopRow(Bytes.toBytes(stopRow)); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertFalse(exists); + + // There is no common prefix between startRow and stopRow. + prefixRow = String.format(prefixFormatter, prefixRowCount-2); + startRow = prefixRow + "#" + String.format(suffixFormatter, 0); + scan = new Scan().withStartRow(Bytes.toBytes(startRow)); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + + if (bt[x] == BloomType.ROWPREFIX_FIXED_LENGTH) { + // startRow and stopRow have a common prefix. + // But the length of the common prefix is less than prefixLength. + String prefixStartRow = String.format(prefixFormatter, prefixRowCount-2); + String prefixStopRow = String.format(prefixFormatter, prefixRowCount-1); + startRow = prefixStartRow + "#" + String.format(suffixFormatter, 0); + stopRow = prefixStopRow + "#" + String.format(suffixFormatter, 0); + scan = new Scan().withStartRow(Bytes.toBytes(startRow)) + .withStopRow(Bytes.toBytes(stopRow)); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + }else if (bt[x] == BloomType.ROWPREFIX_DELIMITED) { + // startRow does not contain delimiter + String prefixStartRow = String.format(prefixFormatter, prefixRowCount-2); + String prefixStopRow = String.format(prefixFormatter, prefixRowCount-2); + startRow = prefixStartRow + String.format(suffixFormatter, 0); + stopRow = prefixStopRow + "#" + String.format(suffixFormatter, 0); + scan = new Scan().withStartRow(Bytes.toBytes(startRow)) + .withStopRow(Bytes.toBytes(stopRow)); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + + // startRow contains delimiter, but stopRow does not have the same prefix as startRow. + prefixStartRow = String.format(prefixFormatter, prefixRowCount-2); + prefixStopRow = String.format(prefixFormatter, prefixRowCount-1); + startRow = prefixStartRow + "#" + String.format(suffixFormatter, 0); + stopRow = prefixStopRow + "#" + String.format(suffixFormatter, 0); + scan = new Scan().withStartRow(Bytes.toBytes(startRow)) + .withStopRow(Bytes.toBytes(stopRow)); + exists = scanner.shouldUseScanner(scan, store, Long.MIN_VALUE); + assertTrue(exists); + } + + reader.close(true); // evict because we are about to delete the file + fs.delete(f, true); + } + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanWithBloomError.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanWithBloomError.java index ae692e96c693..4c58c011ed0c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanWithBloomError.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanWithBloomError.java @@ -46,6 +46,7 @@ import org.apache.hadoop.hbase.regionserver.HRegion.RegionScannerImpl; import org.apache.hadoop.hbase.testclassification.RegionServerTests; import org.apache.hadoop.hbase.testclassification.SmallTests; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.Bytes; import org.junit.Before; import org.junit.ClassRule; @@ -103,6 +104,8 @@ public TestScanWithBloomError(BloomType bloomType) { public void setUp() throws IOException{ conf = TEST_UTIL.getConfiguration(); fs = FileSystem.get(conf); + conf.setInt(BloomFilterUtil.PREFIX_LENGTH_KEY, 10); + conf.set(BloomFilterUtil.DELIMITER_KEY, "#"); } @Test diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSecureBulkLoadManager.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSecureBulkLoadManager.java new file mode 100644 index 000000000000..75ebfd3acfc2 --- /dev/null +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSecureBulkLoadManager.java @@ -0,0 +1,248 @@ +/** + * 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.regionserver; + +import java.io.IOException; +import java.nio.ByteBuffer; +import java.util.Deque; +import java.util.Map; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.atomic.AtomicReference; +import java.util.function.Consumer; + +import org.apache.hadoop.conf.Configuration; +import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.Cell; +import org.apache.hadoop.hbase.DoNotRetryIOException; +import org.apache.hadoop.hbase.HBaseClassTestRule; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; +import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.Connection; +import org.apache.hadoop.hbase.client.Get; +import org.apache.hadoop.hbase.client.Put; +import org.apache.hadoop.hbase.client.Result; +import org.apache.hadoop.hbase.client.Table; +import org.apache.hadoop.hbase.client.TableDescriptor; +import org.apache.hadoop.hbase.io.compress.Compression; +import org.apache.hadoop.hbase.io.crypto.Encryption; +import org.apache.hadoop.hbase.io.hfile.CacheConfig; +import org.apache.hadoop.hbase.io.hfile.HFile; +import org.apache.hadoop.hbase.io.hfile.HFileContext; +import org.apache.hadoop.hbase.io.hfile.HFileContextBuilder; +import org.apache.hadoop.hbase.testclassification.MediumTests; +import org.apache.hadoop.hbase.testclassification.RegionServerTests; +import org.apache.hadoop.hbase.tool.LoadIncrementalHFiles; +import org.apache.hadoop.hbase.util.Bytes; +import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; +import org.apache.hadoop.hbase.util.Threads; +import org.junit.AfterClass; +import org.junit.Assert; +import org.junit.BeforeClass; +import org.junit.ClassRule; +import org.junit.Test; +import org.junit.experimental.categories.Category; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.apache.hbase.thirdparty.com.google.common.collect.Multimap; + + +@Category({RegionServerTests.class, MediumTests.class}) +public class TestSecureBulkLoadManager { + + @ClassRule + public static final HBaseClassTestRule CLASS_RULE = + HBaseClassTestRule.forClass(TestSecureBulkLoadManager.class); + + private static final Logger LOG = + LoggerFactory.getLogger(TestSecureBulkLoadManager.class); + + private static TableName TABLE = TableName.valueOf(Bytes.toBytes("TestSecureBulkLoadManager")); + private static byte[] FAMILY = Bytes.toBytes("family"); + private static byte[] COLUMN = Bytes.toBytes("column"); + private static byte[] key1 = Bytes.toBytes("row1"); + private static byte[] key2 = Bytes.toBytes("row2"); + private static byte[] key3 = Bytes.toBytes("row3"); + private static byte[] value1 = Bytes.toBytes("t1"); + private static byte[] value3 = Bytes.toBytes("t3"); + private static byte[] SPLIT_ROWKEY = key2; + + private Thread ealierBulkload; + private Thread laterBulkload; + + protected final static HBaseTestingUtility testUtil = new HBaseTestingUtility(); + private static Configuration conf = testUtil.getConfiguration(); + + @BeforeClass + public static void setUp() throws Exception { + testUtil.startMiniCluster(); + } + + @AfterClass + public static void tearDown() throws Exception { + testUtil.shutdownMiniCluster(); + testUtil.cleanupTestDir(); + } + + /** + * After a secure bulkload finished , there is a clean-up for FileSystems used in the bulkload. + * Sometimes, FileSystems used in the finished bulkload might also be used in other bulkload + * calls, or there are other FileSystems created by the same user, they could be closed by a + * FileSystem.closeAllForUGI call. So during the clean-up, those FileSystems need to be used + * later can not get closed ,or else a race condition occurs. + * + * testForRaceCondition tests the case that two secure bulkload calls from the same UGI go + * into two different regions and one bulkload finishes earlier when the other bulkload still + * needs its FileSystems, checks that both bulkloads succeed. + */ + @Test + public void testForRaceCondition() throws Exception { + Consumer fsCreatedListener = new Consumer() { + @Override + public void accept(HRegion hRegion) { + if (hRegion.getRegionInfo().containsRow(key3)) { + Threads.shutdown(ealierBulkload);/// wait util the other bulkload finished + } + } + } ; + testUtil.getMiniHBaseCluster().getRegionServerThreads().get(0).getRegionServer() + .secureBulkLoadManager.setFsCreatedListener(fsCreatedListener); + /// create table + testUtil.createTable(TABLE,FAMILY,Bytes.toByteArrays(SPLIT_ROWKEY)); + + /// prepare files + Path rootdir = testUtil.getMiniHBaseCluster().getRegionServerThreads().get(0) + .getRegionServer().getRootDir(); + Path dir1 = new Path(rootdir, "dir1"); + prepareHFile(dir1, key1, value1); + Path dir2 = new Path(rootdir, "dir2"); + prepareHFile(dir2, key3, value3); + + /// do bulkload + final AtomicReference t1Exception = new AtomicReference<>(); + final AtomicReference t2Exception = new AtomicReference<>(); + ealierBulkload = new Thread(new Runnable() { + @Override + public void run() { + try { + doBulkloadWithoutRetry(dir1); + } catch (Exception e) { + LOG.error("bulk load failed .",e); + t1Exception.set(e); + } + } + }); + laterBulkload = new Thread(new Runnable() { + @Override + public void run() { + try { + doBulkloadWithoutRetry(dir2); + } catch (Exception e) { + LOG.error("bulk load failed .",e); + t2Exception.set(e); + } + } + }); + ealierBulkload.start(); + laterBulkload.start(); + Threads.shutdown(ealierBulkload); + Threads.shutdown(laterBulkload); + Assert.assertNull(t1Exception.get()); + Assert.assertNull(t2Exception.get()); + + /// check bulkload ok + Get get1 = new Get(key1); + Get get3 = new Get(key3); + Table t = testUtil.getConnection().getTable(TABLE); + Result r = t.get(get1); + Assert.assertArrayEquals(r.getValue(FAMILY, COLUMN), value1); + r = t.get(get3); + Assert.assertArrayEquals(r.getValue(FAMILY, COLUMN), value3); + + } + + /** + * A trick is used to make sure server-side failures( if any ) not being covered up by a client + * retry. Since LoadIncrementalHFiles.doBulkLoad keeps performing bulkload calls as long as the + * HFile queue is not empty, while server-side exceptions in the doAs block do not lead + * to a client exception, a bulkload will always succeed in this case by default, thus client + * will never be aware that failures have ever happened . To avoid this kind of retry , + * a MyExceptionToAvoidRetry exception is thrown after bulkLoadPhase finished and caught + * silently outside the doBulkLoad call, so that the bulkLoadPhase would be called exactly + * once, and server-side failures, if any ,can be checked via data. + */ + class MyExceptionToAvoidRetry extends DoNotRetryIOException { + } + + private void doBulkloadWithoutRetry(Path dir) throws Exception { + Connection connection = testUtil.getConnection(); + LoadIncrementalHFiles h = new LoadIncrementalHFiles(conf) { + @Override + protected void bulkLoadPhase(final Table htable, final Connection conn, + ExecutorService pool, Deque queue, + final Multimap regionGroups, boolean copyFile, + Map item2RegionMap) throws IOException { + super.bulkLoadPhase(htable, conn, pool, queue, regionGroups, copyFile, item2RegionMap); + throw new MyExceptionToAvoidRetry(); // throw exception to avoid retry + } + }; + try { + h.doBulkLoad(dir, testUtil.getAdmin(), connection.getTable(TABLE), + connection.getRegionLocator(TABLE)); + Assert.fail("MyExceptionToAvoidRetry is expected"); + } catch (MyExceptionToAvoidRetry e) { //expected + } + } + + private void prepareHFile(Path dir, byte[] key, byte[] value) throws Exception { + TableDescriptor desc = testUtil.getAdmin().getDescriptor(TABLE); + ColumnFamilyDescriptor family = desc.getColumnFamily(FAMILY); + Compression.Algorithm compression = HFile.DEFAULT_COMPRESSION_ALGORITHM; + + CacheConfig writerCacheConf = new CacheConfig(conf, family); + writerCacheConf.setCacheDataOnWrite(false); + HFileContext hFileContext = new HFileContextBuilder() + .withIncludesMvcc(false) + .withIncludesTags(true) + .withCompression(compression) + .withCompressTags(family.isCompressTags()) + .withChecksumType(HStore.getChecksumType(conf)) + .withBytesPerCheckSum(HStore.getBytesPerChecksum(conf)) + .withBlockSize(family.getBlocksize()) + .withHBaseCheckSum(true) + .withDataBlockEncoding(family.getDataBlockEncoding()) + .withEncryptionContext(Encryption.Context.NONE) + .withCreateTime(EnvironmentEdgeManager.currentTime()) + .build(); + StoreFileWriter.Builder builder = + new StoreFileWriter.Builder(conf, writerCacheConf, dir.getFileSystem(conf)) + .withOutputDir(new Path(dir, family.getNameAsString())) + .withBloomType(family.getBloomFilterType()) + .withMaxKeyCount(Integer.MAX_VALUE) + .withFileContext(hFileContext); + StoreFileWriter writer = builder.build(); + + Put put = new Put(key); + put.addColumn(FAMILY, COLUMN, value); + for (Cell c : put.get(FAMILY, COLUMN)) { + writer.append(c); + } + + writer.close(); + } +} diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSeekOptimizations.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSeekOptimizations.java index a6a6510b3b1a..1e04e8de8f4b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSeekOptimizations.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSeekOptimizations.java @@ -45,6 +45,7 @@ import org.apache.hadoop.hbase.io.compress.Compression; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.RegionServerTests; +import org.apache.hadoop.hbase.util.BloomFilterUtil; import org.apache.hadoop.hbase.util.Bytes; import org.junit.After; import org.junit.Before; @@ -142,6 +143,8 @@ public TestSeekOptimizations(Compression.Algorithm comprAlgo, public void setUp() { rand = new Random(91238123L); expectedKVs.clear(); + TEST_UTIL.getConfiguration().setInt(BloomFilterUtil.PREFIX_LENGTH_KEY, 10); + TEST_UTIL.getConfiguration().set(BloomFilterUtil.DELIMITER_KEY, "#"); } @Test diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestWALReplay.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestWALReplay.java index 93c379c8ef3d..3f9040be74a2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestWALReplay.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestWALReplay.java @@ -869,7 +869,7 @@ public void testSequentialEditLogSeqNum() throws IOException { final TableName tableName = TableName.valueOf(currentTest.getMethodName()); final HRegionInfo hri = createBasic3FamilyHRegionInfo(tableName); final Path basedir = - FSUtils.getTableDir(this.hbaseRootDir, tableName); + FSUtils.getWALTableDir(conf, tableName); deleteDir(basedir); final byte[] rowName = tableName.getName(); final int countPerFamily = 10; @@ -902,7 +902,7 @@ public void testSequentialEditLogSeqNum() throws IOException { WALSplitter.splitLogFile(hbaseRootDir, listStatus[0], this.fs, this.conf, null, null, null, wals); FileStatus[] listStatus1 = this.fs.listStatus( - new Path(FSUtils.getTableDir(hbaseRootDir, tableName), new Path(hri.getEncodedName(), + new Path(FSUtils.getWALTableDir(conf, tableName), new Path(hri.getEncodedName(), "recovered.edits")), new PathFilter() { @Override public boolean accept(Path p) { @@ -929,13 +929,13 @@ public boolean accept(Path p) { public void testDatalossWhenInputError() throws Exception { final TableName tableName = TableName.valueOf("testDatalossWhenInputError"); final HRegionInfo hri = createBasic3FamilyHRegionInfo(tableName); - final Path basedir = FSUtils.getTableDir(this.hbaseRootDir, tableName); + final Path basedir = FSUtils.getWALTableDir(conf, tableName); deleteDir(basedir); final byte[] rowName = tableName.getName(); final int countPerFamily = 10; final HTableDescriptor htd = createBasic1FamilyHTD(tableName); HRegion region1 = HBaseTestingUtility.createRegionAndWAL(hri, hbaseRootDir, this.conf, htd); - Path regionDir = region1.getRegionFileSystem().getRegionDir(); + Path regionDir = region1.getWALRegionDir(); HBaseTestingUtility.closeRegionAndWAL(region1); WAL wal = createWAL(this.conf, hbaseRootDir, logName); @@ -1110,16 +1110,18 @@ static class TestFlusher implements FlushRequester { private HRegion r; @Override - public void requestFlush(HRegion region, boolean force, FlushLifeCycleTracker tracker) { + public boolean requestFlush(HRegion region, boolean force, FlushLifeCycleTracker tracker) { try { r.flush(force); + return true; } catch (IOException e) { throw new RuntimeException("Exception flushing", e); } } @Override - public void requestDelayedFlush(HRegion region, long when, boolean forceFlushAllStores) { + public boolean requestDelayedFlush(HRegion region, long when, boolean forceFlushAllStores) { + return true; } @Override diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationEndpoint.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationEndpoint.java index 5d833cc5a988..03fbb59f26da 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationEndpoint.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/TestReplicationEndpoint.java @@ -17,7 +17,9 @@ */ package org.apache.hadoop.hbase.replication; +import static org.mockito.Mockito.doNothing; import static org.mockito.Mockito.mock; +import static org.mockito.Mockito.spy; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; @@ -316,11 +318,17 @@ public void testMetricsSourceBaseSourcePassthrough(){ MetricsReplicationSourceImpl globalRms = mock(MetricsReplicationSourceImpl.class); when(globalRms.getMetricsRegistry()).thenReturn(mockRegistry); + MetricsReplicationSourceSource singleSourceSource = new MetricsReplicationSourceSourceImpl(singleRms, id); MetricsReplicationSourceSource globalSourceSource = new MetricsReplicationGlobalSourceSource(globalRms); + MetricsReplicationSourceSource spyglobalSourceSource = spy(globalSourceSource); + doNothing().when(spyglobalSourceSource).incrFailedRecoveryQueue(); + Map singleSourceSourceByTable = new HashMap<>(); - MetricsSource source = new MetricsSource(id, singleSourceSource, globalSourceSource, + MetricsSource source = new MetricsSource(id, singleSourceSource, spyglobalSourceSource, singleSourceSourceByTable); + + String gaugeName = "gauge"; String singleGaugeName = "source.id." + gaugeName; String globalGaugeName = "source." + gaugeName; @@ -340,6 +348,8 @@ public void testMetricsSourceBaseSourcePassthrough(){ source.removeMetric(gaugeName); source.setGauge(gaugeName, delta); source.updateHistogram(counterName, count); + source.incrFailedRecoveryQueue(); + verify(singleRms).decGauge(singleGaugeName, delta); verify(globalRms).decGauge(globalGaugeName, delta); @@ -357,6 +367,7 @@ public void testMetricsSourceBaseSourcePassthrough(){ verify(globalRms).setGauge(globalGaugeName, delta); verify(singleRms).updateHistogram(singleCounterName, count); verify(globalRms).updateHistogram(globalCounterName, count); + verify(spyglobalSourceSource).incrFailedRecoveryQueue(); //check singleSourceSourceByTable metrics. // singleSourceSourceByTable map entry will be created only @@ -373,6 +384,7 @@ public void testMetricsSourceBaseSourcePassthrough(){ // cannot put more concreate value here to verify because the age is arbitrary. // as long as it's greater than 0, we see it as correct answer. Assert.assertTrue(msr.getLastShippedAge() > 0); + } private void doPut(byte[] row) throws IOException { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestAccessController.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestAccessController.java index 163c2ecf8688..78bb5f617d20 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestAccessController.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/access/TestAccessController.java @@ -155,6 +155,7 @@ public class TestAccessController extends SecureTestUtil { public static final HBaseClassTestRule CLASS_RULE = HBaseClassTestRule.forClass(TestAccessController.class); + private static final FsPermission FS_PERMISSION_ALL = FsPermission.valueOf("-rwxrwxrwx"); private static final Logger LOG = LoggerFactory.getLogger(TestAccessController.class); private static TableName TEST_TABLE = TableName.valueOf("testtable1"); private static final HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); @@ -983,7 +984,7 @@ public void testBulkLoad() throws Exception { fs.mkdirs(dir); // need to make it globally writable // so users creating HFiles have write permissions - fs.setPermission(dir, FsPermission.valueOf("-rwxrwxrwx")); + fs.setPermission(dir, FS_PERMISSION_ALL); AccessTestAction bulkLoadAction = new AccessTestAction() { @Override @@ -994,9 +995,8 @@ public Object run() throws Exception { byte[][][] hfileRanges = { { { (byte) 0 }, { (byte) 9 } } }; Path bulkLoadBasePath = new Path(dir, new Path(User.getCurrent().getName())); - new BulkLoadHelper(bulkLoadBasePath).bulkLoadHFile(TEST_TABLE, TEST_FAMILY, - TEST_QUALIFIER, hfileRanges, numRows); - + new BulkLoadHelper(bulkLoadBasePath).initHFileData(TEST_FAMILY, TEST_QUALIFIER, + hfileRanges, numRows, FS_PERMISSION_ALL).bulkLoadHFile(TEST_TABLE); return null; } }; @@ -1014,6 +1014,51 @@ public Object run() throws Exception { } } + private class BulkLoadAccessTestAction implements AccessTestAction { + private FsPermission filePermission; + private Path testDataDir; + + public BulkLoadAccessTestAction(FsPermission perm, Path testDataDir) { + this.filePermission = perm; + this.testDataDir = testDataDir; + } + + @Override + public Object run() throws Exception { + FileSystem fs = TEST_UTIL.getTestFileSystem(); + fs.mkdirs(testDataDir); + fs.setPermission(testDataDir, FS_PERMISSION_ALL); + // Making the assumption that the test table won't split between the range + byte[][][] hfileRanges = { { { (byte) 0 }, { (byte) 9 } } }; + Path bulkLoadBasePath = new Path(testDataDir, new Path(User.getCurrent().getName())); + new BulkLoadHelper(bulkLoadBasePath) + .initHFileData(TEST_FAMILY, TEST_QUALIFIER, hfileRanges, 3, filePermission) + .bulkLoadHFile(TEST_TABLE); + return null; + } + } + + @Test + public void testBulkLoadWithoutWritePermission() throws Exception { + // Use the USER_CREATE to initialize the source directory. + Path testDataDir0 = TEST_UTIL.getDataTestDirOnTestFS("testBulkLoadWithoutWritePermission0"); + Path testDataDir1 = TEST_UTIL.getDataTestDirOnTestFS("testBulkLoadWithoutWritePermission1"); + AccessTestAction bulkLoadAction1 = + new BulkLoadAccessTestAction(FsPermission.valueOf("-r-xr-xr-x"), testDataDir0); + AccessTestAction bulkLoadAction2 = + new BulkLoadAccessTestAction(FS_PERMISSION_ALL, testDataDir1); + // Test the incorrect case. + BulkLoadHelper.setPermission(TEST_UTIL.getTestFileSystem(), + TEST_UTIL.getTestFileSystem().getWorkingDirectory(), FS_PERMISSION_ALL); + try { + USER_CREATE.runAs(bulkLoadAction1); + fail("Should fail because the hbase user has no write permission on hfiles."); + } catch (IOException e) { + } + // Ensure the correct case. + USER_CREATE.runAs(bulkLoadAction2); + } + public static class BulkLoadHelper { private final FileSystem fs; private final Path loadPath; @@ -1029,64 +1074,65 @@ public BulkLoadHelper(Path loadPath) throws IOException { private void createHFile(Path path, byte[] family, byte[] qualifier, byte[] startKey, byte[] endKey, int numRows) throws IOException { - HFile.Writer writer = null; long now = System.currentTimeMillis(); try { HFileContext context = new HFileContextBuilder().build(); - writer = HFile.getWriterFactory(conf, new CacheConfig(conf)) - .withPath(fs, path) - .withFileContext(context) - .create(); + writer = HFile.getWriterFactory(conf, new CacheConfig(conf)).withPath(fs, path) + .withFileContext(context).create(); // subtract 2 since numRows doesn't include boundary keys - for (byte[] key : Bytes.iterateOnSplits(startKey, endKey, true, numRows-2)) { + for (byte[] key : Bytes.iterateOnSplits(startKey, endKey, true, numRows - 2)) { KeyValue kv = new KeyValue(key, family, qualifier, now, key); writer.append(kv); } } finally { - if(writer != null) + if (writer != null) { writer.close(); + } } } - private void bulkLoadHFile( - TableName tableName, - byte[] family, - byte[] qualifier, - byte[][][] hfileRanges, - int numRowsPerRange) throws Exception { - + private BulkLoadHelper initHFileData(byte[] family, byte[] qualifier, byte[][][] hfileRanges, + int numRowsPerRange, FsPermission filePermission) throws Exception { Path familyDir = new Path(loadPath, Bytes.toString(family)); fs.mkdirs(familyDir); int hfileIdx = 0; + List hfiles = new ArrayList<>(); for (byte[][] range : hfileRanges) { byte[] from = range[0]; byte[] to = range[1]; - createHFile(new Path(familyDir, "hfile_"+(hfileIdx++)), - family, qualifier, from, to, numRowsPerRange); + Path hfile = new Path(familyDir, "hfile_" + (hfileIdx++)); + hfiles.add(hfile); + createHFile(hfile, family, qualifier, from, to, numRowsPerRange); } - //set global read so RegionServer can move it - setPermission(loadPath, FsPermission.valueOf("-rwxrwxrwx")); - + // set global read so RegionServer can move it + setPermission(fs, loadPath, FS_PERMISSION_ALL); + // Ensure the file permission as requested. + for (Path hfile : hfiles) { + setPermission(fs, hfile, filePermission); + } + return this; + } + private void bulkLoadHFile(TableName tableName) throws Exception { try (Connection conn = ConnectionFactory.createConnection(conf); - Admin admin = conn.getAdmin(); - RegionLocator locator = conn.getRegionLocator(tableName); - Table table = conn.getTable(tableName)) { + Admin admin = conn.getAdmin(); + RegionLocator locator = conn.getRegionLocator(tableName); + Table table = conn.getTable(tableName)) { TEST_UTIL.waitUntilAllRegionsAssigned(tableName); LoadIncrementalHFiles loader = new LoadIncrementalHFiles(conf); loader.doBulkLoad(loadPath, admin, table, locator); } } - public void setPermission(Path dir, FsPermission perm) throws IOException { - if(!fs.getFileStatus(dir).isDirectory()) { - fs.setPermission(dir,perm); - } - else { - for(FileStatus el : fs.listStatus(dir)) { + private static void setPermission(FileSystem fs, Path dir, FsPermission perm) + throws IOException { + if (!fs.getFileStatus(dir).isDirectory()) { + fs.setPermission(dir, perm); + } else { + for (FileStatus el : fs.listStatus(dir)) { fs.setPermission(el.getPath(), perm); - setPermission(el.getPath() , perm); + setPermission(fs, el.getPath(), perm); } } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/MobSnapshotTestingUtils.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/MobSnapshotTestingUtils.java index 75b6c235dc43..9ee433631210 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/MobSnapshotTestingUtils.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/MobSnapshotTestingUtils.java @@ -20,10 +20,14 @@ import static org.junit.Assert.assertEquals; import java.io.IOException; - +import org.apache.commons.lang3.StringUtils; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.fs.Path; +import org.apache.hadoop.hbase.Cell; +import org.apache.hadoop.hbase.CellUtil; +import org.apache.hadoop.hbase.HBaseTestingUtility; +import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptorBuilder; import org.apache.hadoop.hbase.client.ConnectionFactory; import org.apache.hadoop.hbase.client.Result; @@ -32,11 +36,7 @@ import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.client.TableDescriptorBuilder; -import org.apache.hadoop.hbase.Cell; -import org.apache.hadoop.hbase.CellUtil; -import org.apache.hadoop.hbase.HBaseTestingUtility; import org.apache.hadoop.hbase.regionserver.BloomType; -import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.util.Bytes; import org.junit.Assert; @@ -59,23 +59,28 @@ public static void createPreSplitMobTable(final HBaseTestingUtility util, 1, families); } - private static void createMobTable(final HBaseTestingUtility util, - final TableName tableName, final byte[][] splitKeys, int regionReplication, - final byte[]... families) throws IOException, InterruptedException { - TableDescriptorBuilder builder - = TableDescriptorBuilder.newBuilder(tableName) - .setRegionReplication(regionReplication); + public static void createMobTable(final HBaseTestingUtility util, final TableName tableName, + final byte[][] splitKeys, int regionReplication, final byte[]... families) + throws IOException, InterruptedException { + createMobTable(util, tableName, splitKeys, regionReplication, null, families); + } + + public static void createMobTable(HBaseTestingUtility util, TableName tableName, + byte[][] splitKeys, int regionReplication, String cpClassName, byte[]... families) + throws IOException, InterruptedException { + TableDescriptorBuilder builder = + TableDescriptorBuilder.newBuilder(tableName).setRegionReplication(regionReplication); for (byte[] family : families) { - builder.setColumnFamily(ColumnFamilyDescriptorBuilder - .newBuilder(family) - .setMobEnabled(true) - .setMobThreshold(0L) - .build()); + builder.setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(family).setMobEnabled(true) + .setMobThreshold(0L).build()); + } + if (!StringUtils.isBlank(cpClassName)) { + builder.setCoprocessor(cpClassName); } util.getAdmin().createTable(builder.build(), splitKeys); SnapshotTestingUtils.waitForTableToBeOnline(util, tableName); - assertEquals((splitKeys.length + 1) * regionReplication, util - .getAdmin().getTableRegions(tableName).size()); + assertEquals((splitKeys.length + 1) * regionReplication, + util.getAdmin().getRegions(tableName).size()); } /** diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/tool/TestCanaryTool.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/tool/TestCanaryTool.java index cdbf42623c78..6c23764a46f4 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/tool/TestCanaryTool.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/tool/TestCanaryTool.java @@ -35,6 +35,7 @@ import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; import org.apache.hadoop.hbase.client.Put; +import org.apache.hadoop.hbase.client.RegionInfo; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -114,11 +115,11 @@ public void testBasicCanaryWorks() throws Exception { ExecutorService executor = new ScheduledThreadPoolExecutor(1); Canary.RegionStdOutSink sink = spy(new Canary.RegionStdOutSink()); Canary canary = new Canary(executor, sink); - String[] args = { "-writeSniffing", "-t", "10000", name.getMethodName() }; + String[] args = { "-writeSniffing", "-t", "10000", tableName.getNameAsString() }; assertEquals(0, ToolRunner.run(testingUtility.getConfiguration(), canary, args)); assertEquals("verify no read error count", 0, canary.getReadFailures().size()); assertEquals("verify no write error count", 0, canary.getWriteFailures().size()); - verify(sink, atLeastOnce()).publishReadTiming(isA(ServerName.class), isA(HRegionInfo.class), + verify(sink, atLeastOnce()).publishReadTiming(isA(ServerName.class), isA(RegionInfo.class), isA(ColumnFamilyDescriptor.class), anyLong()); } @@ -144,7 +145,8 @@ public void testReadTableTimeouts() throws Exception { Canary canary = new Canary(executor, sink); String configuredTimeoutStr = tableNames[0].getNameAsString() + "=" + Long.MAX_VALUE + "," + tableNames[1].getNameAsString() + "=0"; - String[] args = { "-readTableTimeouts", configuredTimeoutStr, name.getMethodName() + "1", name.getMethodName() + "2"}; + String[] args = {"-readTableTimeouts", configuredTimeoutStr, name.getMethodName() + "1", + name.getMethodName() + "2"}; assertEquals(0, ToolRunner.run(testingUtility.getConfiguration(), canary, args)); verify(sink, times(tableNames.length)).initializeAndGetReadLatencyForTable(isA(String.class)); for (int i=0; i<2; i++) { @@ -231,7 +233,7 @@ public void testRawScanConfig() throws Exception { conf.setBoolean(HConstants.HBASE_CANARY_READ_RAW_SCAN_KEY, true); assertEquals(0, ToolRunner.run(conf, canary, args)); verify(sink, atLeastOnce()) - .publishReadTiming(isA(ServerName.class), isA(HRegionInfo.class), + .publishReadTiming(isA(ServerName.class), isA(RegionInfo.class), isA(ColumnFamilyDescriptor.class), anyLong()); assertEquals("verify no read error count", 0, canary.getReadFailures().size()); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestReadWriteSeqIdFiles.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestReadWriteSeqIdFiles.java index 6e3aa105f700..8ae638ce9a4d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestReadWriteSeqIdFiles.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestReadWriteSeqIdFiles.java @@ -49,13 +49,13 @@ public class TestReadWriteSeqIdFiles { private static final HBaseCommonTestingUtility UTIL = new HBaseCommonTestingUtility(); - private static FileSystem FS; + private static FileSystem walFS; private static Path REGION_DIR; @BeforeClass public static void setUp() throws IOException { - FS = FileSystem.getLocal(UTIL.getConfiguration()); + walFS = FileSystem.getLocal(UTIL.getConfiguration()); REGION_DIR = UTIL.getDataTestDir(); } @@ -66,20 +66,20 @@ public static void tearDown() throws IOException { @Test public void test() throws IOException { - WALSplitter.writeRegionSequenceIdFile(FS, REGION_DIR, 1000L); - assertEquals(1000L, WALSplitter.getMaxRegionSequenceId(FS, REGION_DIR)); - WALSplitter.writeRegionSequenceIdFile(FS, REGION_DIR, 2000L); - assertEquals(2000L, WALSplitter.getMaxRegionSequenceId(FS, REGION_DIR)); + WALSplitter.writeRegionSequenceIdFile(walFS, REGION_DIR, 1000L); + assertEquals(1000L, WALSplitter.getMaxRegionSequenceId(walFS, REGION_DIR)); + WALSplitter.writeRegionSequenceIdFile(walFS, REGION_DIR, 2000L); + assertEquals(2000L, WALSplitter.getMaxRegionSequenceId(walFS, REGION_DIR)); // can not write a sequence id which is smaller try { - WALSplitter.writeRegionSequenceIdFile(FS, REGION_DIR, 1500L); + WALSplitter.writeRegionSequenceIdFile(walFS, REGION_DIR, 1500L); } catch (IOException e) { // expected LOG.info("Expected error", e); } Path editsdir = WALSplitter.getRegionDirRecoveredEditsDir(REGION_DIR); - FileStatus[] files = FSUtils.listStatus(FS, editsdir, new PathFilter() { + FileStatus[] files = FSUtils.listStatus(walFS, editsdir, new PathFilter() { @Override public boolean accept(Path p) { return WALSplitter.isSequenceIdFile(p); @@ -89,7 +89,7 @@ public boolean accept(Path p) { assertEquals(1, files.length); // verify all seqId files aren't treated as recovered.edits files - NavigableSet recoveredEdits = WALSplitter.getSplitEditFilesSorted(FS, REGION_DIR); + NavigableSet recoveredEdits = WALSplitter.getSplitEditFilesSorted(walFS, REGION_DIR); assertEquals(0, recoveredEdits.size()); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALFactory.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALFactory.java index d19265f32728..a20a0717df57 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALFactory.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALFactory.java @@ -181,7 +181,7 @@ public void testSplit() throws IOException { final MultiVersionConcurrencyControl mvcc = new MultiVersionConcurrencyControl(1); final int howmany = 3; RegionInfo[] infos = new RegionInfo[3]; - Path tabledir = FSUtils.getTableDir(hbaseDir, tableName); + Path tabledir = FSUtils.getWALTableDir(conf, tableName); fs.mkdirs(tabledir); for (int i = 0; i < howmany; i++) { infos[i] = RegionInfoBuilder.newBuilder(tableName).setStartKey(Bytes.toBytes("" + i)) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALSplit.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALSplit.java index 7a5abfd98c41..e6644f07ddae 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALSplit.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/wal/TestWALSplit.java @@ -253,9 +253,9 @@ public Integer run() throws Exception { } LOG.debug(Objects.toString(ls)); LOG.info("Splitting WALs out from under zombie. Expecting " + numWriters + " files."); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf2, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf2, wals); LOG.info("Finished splitting out from under zombie."); - Path[] logfiles = getLogForRegion(HBASEDIR, TABLE_NAME, region); + Path[] logfiles = getLogForRegion(TABLE_NAME, region); assertEquals("wrong number of split files for region", numWriters, logfiles.length); int count = 0; for (Path logfile: logfiles) { @@ -440,9 +440,9 @@ public void testSplitPreservesEdits() throws IOException{ generateWALs(1, 10, -1, 0); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); Path originalLog = (fs.listStatus(OLDLOGDIR))[0].getPath(); - Path[] splitLog = getLogForRegion(HBASEDIR, TABLE_NAME, REGION); + Path[] splitLog = getLogForRegion(TABLE_NAME, REGION); assertEquals(1, splitLog.length); assertTrue("edits differ after split", logsAreEqual(originalLog, splitLog[0])); @@ -456,9 +456,9 @@ public void testSplitRemovesRegionEventsEdits() throws IOException{ generateWALs(1, 10, -1, 100); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); Path originalLog = (fs.listStatus(OLDLOGDIR))[0].getPath(); - Path[] splitLog = getLogForRegion(HBASEDIR, TABLE_NAME, REGION); + Path[] splitLog = getLogForRegion(TABLE_NAME, REGION); assertEquals(1, splitLog.length); assertFalse("edits differ after split", logsAreEqual(originalLog, splitLog[0])); @@ -483,13 +483,13 @@ public void testSplitLeavesCompactionEventsEdits() throws IOException{ writer.close(); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); Path originalLog = (fs.listStatus(OLDLOGDIR))[0].getPath(); // original log should have 10 test edits, 10 region markers, 1 compaction marker assertEquals(21, countWAL(originalLog)); - Path[] splitLog = getLogForRegion(HBASEDIR, TABLE_NAME, hri.getEncodedName()); + Path[] splitLog = getLogForRegion(TABLE_NAME, hri.getEncodedName()); assertEquals(1, splitLog.length); assertFalse("edits differ after split", logsAreEqual(originalLog, splitLog[0])); @@ -504,10 +504,10 @@ public void testSplitLeavesCompactionEventsEdits() throws IOException{ private int splitAndCount(final int expectedFiles, final int expectedEntries) throws IOException { useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); int result = 0; for (String region : REGIONS) { - Path[] logfiles = getLogForRegion(HBASEDIR, TABLE_NAME, region); + Path[] logfiles = getLogForRegion(TABLE_NAME, region); assertEquals(expectedFiles, logfiles.length); int count = 0; for (Path logfile: logfiles) { @@ -640,7 +640,7 @@ private Set splitCorruptWALs(final FaultyProtobufLogReader.FailureType f walDirContents.add(status.getPath().getName()); } useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); return walDirContents; } finally { conf.setClass("hbase.regionserver.hlog.reader.impl", backupClass, @@ -681,9 +681,9 @@ private void ignoreCorruption(final Corruptions corruption, final int entryCount corruptWAL(c1, corruption, true); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); - Path[] splitLog = getLogForRegion(HBASEDIR, TABLE_NAME, REGION); + Path[] splitLog = getLogForRegion(TABLE_NAME, REGION); assertEquals(1, splitLog.length); int actualCount = 0; @@ -717,7 +717,7 @@ public void testLogsGetArchivedAfterSplit() throws IOException { conf.setBoolean(HBASE_SKIP_ERRORS, false); generateWALs(-1); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); FileStatus[] archivedLogs = fs.listStatus(OLDLOGDIR); assertEquals("wrong number of files in the archive log", NUM_WRITERS, archivedLogs.length); } @@ -733,7 +733,7 @@ public void testLogDirectoryShouldBeDeletedAfterSuccessfulSplit() throws IOException { generateWALs(-1); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); FileStatus [] statuses = null; try { statuses = fs.listStatus(WALDIR); @@ -763,7 +763,7 @@ public void testSplitWillFailIfWritingToRegionFails() throws Exception { try { InstrumentedLogWriter.activateFailure = true; - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); } catch (IOException e) { assertTrue(e.getMessage(). contains("This exception is instrumented and should only be thrown for testing")); @@ -784,7 +784,7 @@ public void testSplitDeletedRegion() throws IOException { Path regiondir = new Path(TABLEDIR, region); fs.delete(regiondir, true); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); assertFalse(fs.exists(regiondir)); } @@ -861,7 +861,7 @@ private void retryOverHdfsProblem(final FileSystem spiedFs) throws Exception { useDifferentDFSClient(); try { - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, spiedFs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, spiedFs, conf, wals); assertEquals(NUM_WRITERS, fs.listStatus(OLDLOGDIR).length); assertFalse(fs.exists(WALDIR)); } catch (IOException e) { @@ -1085,7 +1085,7 @@ public void testSplitLogFileDeletedRegionDir() throws IOException { Path regiondir = new Path(TABLEDIR, REGION); LOG.info("Region directory is" + regiondir); fs.delete(regiondir, true); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); assertFalse(fs.exists(regiondir)); } @@ -1098,7 +1098,7 @@ public void testSplitLogFileEmpty() throws IOException { injectEmptyFile(".empty", true); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); Path tdir = FSUtils.getTableDir(HBASEDIR, TABLE_NAME); assertFalse(fs.exists(tdir)); @@ -1123,7 +1123,7 @@ public void testSplitLogFileFirstLineCorruptionLog() Corruptions.INSERT_GARBAGE_ON_FIRST_LINE, true); useDifferentDFSClient(); - WALSplitter.split(HBASEDIR, WALDIR, OLDLOGDIR, fs, conf, wals); + WALSplitter.split(HBASELOGDIR, WALDIR, OLDLOGDIR, fs, conf, wals); final Path corruptDir = new Path(FSUtils.getWALRootDir(conf), HConstants.CORRUPT_DIR_NAME); assertEquals(1, fs.listStatus(corruptDir).length); @@ -1151,14 +1151,14 @@ public void testConcurrentSplitLogAndReplayRecoverEdit() throws IOException { @Override protected Writer createWriter(Path logfile) throws IOException { - Writer writer = wals.createRecoveredEditsWriter(this.fs, logfile); + Writer writer = wals.createRecoveredEditsWriter(this.walFS, logfile); // After creating writer, simulate region's // replayRecoveredEditsIfAny() which gets SplitEditFiles of this // region and delete them, excluding files with '.temp' suffix. NavigableSet files = WALSplitter.getSplitEditFilesSorted(fs, regiondir); if (files != null && !files.isEmpty()) { for (Path file : files) { - if (!this.fs.delete(file, false)) { + if (!this.walFS.delete(file, false)) { LOG.error("Failed delete of " + file); } else { LOG.debug("Deleted recovered.edits file=" + file); @@ -1237,9 +1237,9 @@ private Writer generateWALs(int writers, int entries, int leaveOpen, int regionE - private Path[] getLogForRegion(Path rootdir, TableName table, String region) + private Path[] getLogForRegion(TableName table, String region) throws IOException { - Path tdir = FSUtils.getTableDir(rootdir, table); + Path tdir = FSUtils.getWALTableDir(conf, table); @SuppressWarnings("deprecation") Path editsdir = WALSplitter.getRegionDirRecoveredEditsDir(HRegion.getRegionDir(tdir, Bytes.toString(Bytes.toBytes(region)))); diff --git a/hbase-shell/src/main/ruby/hbase/admin.rb b/hbase-shell/src/main/ruby/hbase/admin.rb index 2be059dadc3f..898feae8e965 100644 --- a/hbase-shell/src/main/ruby/hbase/admin.rb +++ b/hbase-shell/src/main/ruby/hbase/admin.rb @@ -1063,6 +1063,12 @@ def list_table_snapshots(tableNameRegex, snapshotNameRegex = '.*') Pattern.compile(snapshotNameRegex)).to_a end + #---------------------------------------------------------------------------------------------- + # Returns the ClusterStatus of the cluster + def getClusterStatus + @admin.getClusterStatus + end + #---------------------------------------------------------------------------------------------- # Returns a list of regionservers def getRegionServers @@ -1224,15 +1230,6 @@ def get_security_capabilities @admin.getSecurityCapabilities end - # Abort a procedure - def abort_procedure?(proc_id, may_interrupt_if_running = nil) - if may_interrupt_if_running.nil? - @admin.abortProcedure(proc_id, true) - else - @admin.abortProcedure(proc_id, may_interrupt_if_running) - end - end - # List all procedures def list_procedures @admin.getProcedures diff --git a/hbase-shell/src/main/ruby/hbase/table.rb b/hbase-shell/src/main/ruby/hbase/table.rb index 55211b00561d..7a334a081436 100644 --- a/hbase-shell/src/main/ruby/hbase/table.rb +++ b/hbase-shell/src/main/ruby/hbase/table.rb @@ -778,13 +778,16 @@ def convert(column, kv, converter_class = 'org.apache.hadoop.hbase.util.Bytes', end def convert_bytes(bytes, converter_class = nil, converter_method = nil) - convert_bytes_with_position(bytes, 0, bytes.length, converter_class, converter_method) + # Avoid nil + converter_class ||= 'org.apache.hadoop.hbase.util.Bytes' + converter_method ||= 'toStringBinary' + eval(converter_class).method(converter_method).call(bytes) end def convert_bytes_with_position(bytes, offset, len, converter_class, converter_method) # Avoid nil - converter_class = 'org.apache.hadoop.hbase.util.Bytes' unless converter_class - converter_method = 'toStringBinary' unless converter_method + converter_class ||= 'org.apache.hadoop.hbase.util.Bytes' + converter_method ||= 'toStringBinary' eval(converter_class).method(converter_method).call(bytes, offset, len) end diff --git a/hbase-shell/src/main/ruby/shell.rb b/hbase-shell/src/main/ruby/shell.rb index 17563d3cec65..1507ca393b16 100644 --- a/hbase-shell/src/main/ruby/shell.rb +++ b/hbase-shell/src/main/ruby/shell.rb @@ -361,6 +361,7 @@ def help_footer clear_block_cache stop_master stop_regionserver + rit ], # TODO: remove older hlog_roll command aliases: { @@ -451,7 +452,6 @@ def help_footer 'procedures', full_name: 'PROCEDURES & LOCKS MANAGEMENT', commands: %w[ - abort_procedure list_procedures list_locks ] diff --git a/hbase-shell/src/main/ruby/shell/commands/list_procedures.rb b/hbase-shell/src/main/ruby/shell/commands/list_procedures.rb index 68842a0410d0..1d86b8dcddd1 100644 --- a/hbase-shell/src/main/ruby/shell/commands/list_procedures.rb +++ b/hbase-shell/src/main/ruby/shell/commands/list_procedures.rb @@ -31,8 +31,7 @@ def help end def command - formatter.header(%w[Id Name State Submitted_Time Last_Update Parameters]) - + formatter.header(%w[PID Name State Submitted Last_Update Parameters]) list = JSON.parse(admin.list_procedures) list.each do |proc| submitted_time = Time.at(Integer(proc['submittedTime']) / 1000).to_s diff --git a/hbase-shell/src/main/ruby/shell/commands/abort_procedure.rb b/hbase-shell/src/main/ruby/shell/commands/rit.rb similarity index 54% rename from hbase-shell/src/main/ruby/shell/commands/abort_procedure.rb rename to hbase-shell/src/main/ruby/shell/commands/rit.rb index 28c7d8525d6b..cdb49cf1f3a4 100644 --- a/hbase-shell/src/main/ruby/shell/commands/abort_procedure.rb +++ b/hbase-shell/src/main/ruby/shell/commands/rit.rb @@ -1,5 +1,4 @@ # -# # 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 @@ -19,28 +18,22 @@ module Shell module Commands - class AbortProcedure < Command + # List all regions in transition + class Rit < Command def help <<-EOF -Given a procedure Id (and optional boolean may_interrupt_if_running parameter, -default is true), abort a procedure in hbase. Use with caution. Some procedures -might not be abortable. For experts only. - -If this command is accepted and the procedure is in the process of aborting, -it will return true; if the procedure could not be aborted (eg. procedure -does not exist, or procedure already completed or abort will cause corruption), -this command will return false. - +List all regions in transition. Examples: - - hbase> abort_procedure proc_id - hbase> abort_procedure proc_id, true - hbase> abort_procedure proc_id, false -EOF + hbase> rit + EOF end - def command(proc_id, may_interrupt_if_running = nil) - formatter.row([admin.abort_procedure?(proc_id, may_interrupt_if_running).to_s]) + def command + rit = admin.getClusterStatus.getRegionStatesInTransition + rit.each do |v| + formatter.row([v.toDescriptiveString]) + end + formatter.footer(rit.size) end end end diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientWithRegionReplicas.java b/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestAdminShell2.java similarity index 71% rename from hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientWithRegionReplicas.java rename to hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestAdminShell2.java index b67c2883cc56..e2dadd059346 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestCloneSnapshotFromClientWithRegionReplicas.java +++ b/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestAdminShell2.java @@ -17,22 +17,26 @@ */ package org.apache.hadoop.hbase.client; +import java.io.IOException; import org.apache.hadoop.hbase.HBaseClassTestRule; import org.apache.hadoop.hbase.testclassification.ClientTests; import org.apache.hadoop.hbase.testclassification.LargeTests; +import org.jruby.embed.PathType; import org.junit.ClassRule; +import org.junit.Test; import org.junit.experimental.categories.Category; -@Category({LargeTests.class, ClientTests.class}) -public class TestCloneSnapshotFromClientWithRegionReplicas extends - TestCloneSnapshotFromClient { +@Category({ ClientTests.class, LargeTests.class }) +public class TestAdminShell2 extends AbstractTestShell { @ClassRule public static final HBaseClassTestRule CLASS_RULE = - HBaseClassTestRule.forClass(TestCloneSnapshotFromClientWithRegionReplicas.class); + HBaseClassTestRule.forClass(TestAdminShell2.class); - @Override - protected int getNumReplicas() { - return 3; + @Test + public void testRunShellTests() throws IOException { + System.setProperty("shell.test.include", "admin2_test.rb"); + // Start all ruby tests + jruby.runScriptlet(PathType.ABSOLUTE, "src/test/ruby/tests_runner.rb"); } } diff --git a/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestShell.java b/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestShell.java index ab36edc278b7..9bb8eacce894 100644 --- a/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestShell.java +++ b/hbase-shell/src/test/java/org/apache/hadoop/hbase/client/TestShell.java @@ -39,5 +39,4 @@ public void testRunShellTests() throws IOException { // Start all ruby tests jruby.runScriptlet(PathType.ABSOLUTE, "src/test/ruby/tests_runner.rb"); } - } diff --git a/hbase-shell/src/test/ruby/hbase/admin2_test.rb b/hbase-shell/src/test/ruby/hbase/admin2_test.rb new file mode 100644 index 000000000000..a9efaca3f805 --- /dev/null +++ b/hbase-shell/src/test/ruby/hbase/admin2_test.rb @@ -0,0 +1,295 @@ +# +# +# 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. +# + +require 'shell' +require 'stringio' +require 'hbase_constants' +require 'hbase/hbase' +require 'hbase/table' + +include HBaseConstants + +module Hbase + # Tests for the `status` shell command + class StatusTest < Test::Unit::TestCase + include TestHelpers + + def setup + setup_hbase + # Create test table if it does not exist + @test_name = 'hbase_shell_admin2_test_table' + drop_test_table(@test_name) + create_test_table(@test_name) + end + + def teardown + shutdown + end + + define_test 'Get replication status' do + output = capture_stdout { replication_status('replication', 'both') } + puts "Status output:\n#{output}" + assert output.include? 'SOURCE' + assert output.include? 'SINK' + end + + define_test 'Get replication source metrics information' do + output = capture_stdout { replication_status('replication', 'source') } + puts "Status output:\n#{output}" + assert output.include? 'SOURCE' + end + + define_test 'Get replication sink metrics information' do + output = capture_stdout { replication_status('replication', 'sink') } + puts "Status output:\n#{output}" + assert output.include? 'SINK' + end + + define_test 'Get simple status' do + output = capture_stdout { admin.status('simple', '') } + puts "Status output:\n#{output}" + assert output.include? 'active master' + end + + define_test 'Get detailed status' do + output = capture_stdout { admin.status('detailed', '') } + puts "Status output:\n#{output}" + # Some text which isn't in the simple output + assert output.include? 'regionsInTransition' + end + end + + # Simple administration methods tests + # rubocop:disable ClassLength + class AdminSnapshotTest < Test::Unit::TestCase + include TestHelpers + + def setup + setup_hbase + # Create test table if it does not exist + @test_name = "hbase_shell_tests_table" + drop_test_table(@test_name) + create_test_table(@test_name) + # Test snapshot name + @create_test_snapshot = 'hbase_shell_tests_snapshot' + end + + def teardown + shutdown + end + + #------------------------------------------------------------------------------- + define_test "Snapshot should fail with non-string table name" do + assert_raise(ArgumentError) do + command(:snapshot, 123, 'xxx') + end + end + + define_test "Snapshot should fail with non-string snapshot name" do + assert_raise(ArgumentError) do + command(:snapshot, @test_name, 123) + end + end + + define_test "Snapshot should fail without snapshot name" do + assert_raise(ArgumentError) do + command(:snapshot, @test_name) + end + end + + define_test "Snapshot should work with string args" do + drop_test_snapshot() + command(:snapshot, @test_name, @create_test_snapshot) + list = command(:list_snapshots, @create_test_snapshot) + assert_equal(1, list.size) + end + + define_test "Snapshot should work when SKIP_FLUSH args" do + drop_test_snapshot() + command(:snapshot, @test_name, @create_test_snapshot, {SKIP_FLUSH => true}) + list = command(:list_snapshots, @create_test_snapshot) + assert_equal(1, list.size) + end + + define_test "List snapshot without any args" do + drop_test_snapshot() + command(:snapshot, @test_name, @create_test_snapshot) + list = command(:list_snapshots) + assert_equal(1, list.size) + end + + define_test "List snapshot for a non-existing snapshot" do + list = command(:list_snapshots, "xyz") + assert_equal(0, list.size) + end + + define_test "Restore snapshot without any args" do + assert_raise(ArgumentError) do + command(:restore_snapshot) + end + end + + define_test 'Restore snapshot should work' do + drop_test_snapshot + restore_table = 'test_restore_snapshot_table' + command(:create, restore_table, 'f1', 'f2') + assert_match(/f1/, admin.describe(restore_table)) + assert_match(/f2/, admin.describe(restore_table)) + command(:snapshot, restore_table, @create_test_snapshot) + command(:alter, restore_table, METHOD => 'delete', NAME => 'f1') + assert_no_match(/f1/, admin.describe(restore_table)) + assert_match(/f2/, admin.describe(restore_table)) + drop_test_table(restore_table) + command(:restore_snapshot, @create_test_snapshot) + assert_match(/f1/, admin.describe(restore_table)) + assert_match(/f2/, admin.describe(restore_table)) + drop_test_table(restore_table) + end + + define_test 'Restore snapshot should fail' do + drop_test_snapshot + restore_table = 'test_restore_snapshot_table' + command(:create, restore_table, 'f1', 'f2') + assert_match(/f1/, admin.describe(restore_table)) + assert_match(/f2/, admin.describe(restore_table)) + command(:snapshot, restore_table, @create_test_snapshot) + assert_raise(RuntimeError) do + command(:restore_snapshot, @create_test_snapshot) + end + drop_test_table(restore_table) + end + + define_test "Clone snapshot without any args" do + assert_raise(ArgumentError) do + command(:restore_snapshot) + end + end + + define_test "Clone snapshot without table name args" do + assert_raise(ArgumentError) do + command(:clone_snapshot, @create_test_snapshot) + end + end + + define_test "Clone snapshot should work" do + drop_test_snapshot() + clone_table = "test_clone_snapshot_table" + assert_match(eval("/" + "x" + "/"), admin.describe(@test_name)) + assert_match(eval("/" + "y" + "/"), admin.describe(@test_name)) + command(:snapshot, @test_name, @create_test_snapshot) + command(:clone_snapshot, @create_test_snapshot, clone_table) + assert_match(eval("/" + "x" + "/"), admin.describe(clone_table)) + assert_match(eval("/" + "y" + "/"), admin.describe(clone_table)) + drop_test_table(clone_table) + end + + define_test "Delete snapshot without any args" do + assert_raise(ArgumentError) do + admin.delete_snapshot() + end + end + + define_test "Delete snapshot should work" do + drop_test_snapshot() + command(:snapshot, @test_name, @create_test_snapshot) + list = command(:list_snapshots) + assert_equal(1, list.size) + admin.delete_snapshot(@create_test_snapshot) + list = command(:list_snapshots) + assert_equal(0, list.size) + end + + define_test "Delete all snapshots without any args" do + assert_raise(ArgumentError) do + admin.delete_all_snapshot() + end + end + + define_test "Delete all snapshots should work" do + drop_test_snapshot() + command(:snapshot, @test_name, "delete_all_snapshot1") + command(:snapshot, @test_name, "delete_all_snapshot2") + command(:snapshot, @test_name, "snapshot_delete_all_1") + command(:snapshot, @test_name, "snapshot_delete_all_2") + list = command(:list_snapshots) + assert_equal(4, list.size) + admin.delete_all_snapshot("d.*") + list = command(:list_snapshots) + assert_equal(2, list.size) + admin.delete_all_snapshot(".*") + list = command(:list_snapshots) + assert_equal(0, list.size) + end + + define_test "Delete table snapshots without any args" do + assert_raise(ArgumentError) do + admin.delete_table_snapshots() + end + end + + define_test "Delete table snapshots should work" do + drop_test_snapshot() + command(:snapshot, @test_name, "delete_table_snapshot1") + command(:snapshot, @test_name, "delete_table_snapshot2") + command(:snapshot, @test_name, "snapshot_delete_table1") + new_table = "test_delete_table_snapshots_table" + command(:create, new_table, 'f1') + command(:snapshot, new_table, "delete_table_snapshot3") + list = command(:list_snapshots) + assert_equal(4, list.size) + admin.delete_table_snapshots(@test_name, "d.*") + list = command(:list_snapshots) + assert_equal(2, list.size) + admin.delete_table_snapshots(@test_name) + list = command(:list_snapshots) + assert_equal(1, list.size) + admin.delete_table_snapshots(".*", "d.*") + list = command(:list_snapshots) + assert_equal(0, list.size) + drop_test_table(new_table) + end + + define_test "List table snapshots without any args" do + assert_raise(ArgumentError) do + command(:list_table_snapshots) + end + end + + define_test "List table snapshots should work" do + drop_test_snapshot() + command(:snapshot, @test_name, "delete_table_snapshot1") + command(:snapshot, @test_name, "delete_table_snapshot2") + command(:snapshot, @test_name, "snapshot_delete_table1") + new_table = "test_list_table_snapshots_table" + command(:create, new_table, 'f1') + command(:snapshot, new_table, "delete_table_snapshot3") + list = command(:list_table_snapshots, ".*") + assert_equal(4, list.size) + list = command(:list_table_snapshots, @test_name, "d.*") + assert_equal(2, list.size) + list = command(:list_table_snapshots, @test_name) + assert_equal(3, list.size) + admin.delete_table_snapshots(".*") + list = command(:list_table_snapshots, ".*", ".*") + assert_equal(0, list.size) + drop_test_table(new_table) + end + end + # rubocop:enable ClassLength +end diff --git a/hbase-shell/src/test/ruby/hbase/admin_test.rb b/hbase-shell/src/test/ruby/hbase/admin_test.rb index 1a129217a650..9fafea4afcc9 100644 --- a/hbase-shell/src/test/ruby/hbase/admin_test.rb +++ b/hbase-shell/src/test/ruby/hbase/admin_test.rb @@ -32,7 +32,7 @@ class AdminHelpersTest < Test::Unit::TestCase def setup setup_hbase # Create test table if it does not exist - @test_name = "hbase_shell_tests_table" + @test_name = "hbase_shell_admin_test_table" create_test_table(@test_name) end @@ -626,271 +626,4 @@ def teardown end end # rubocop:enable Metrics/ClassLength - - # Tests for the `status` shell command - class StatusTest < Test::Unit::TestCase - include TestHelpers - - def setup - setup_hbase - # Create test table if it does not exist - @test_name = 'hbase_shell_tests_table' - drop_test_table(@test_name) - create_test_table(@test_name) - end - - def teardown - shutdown - end - - define_test 'Get replication status' do - output = capture_stdout { replication_status('replication', 'both') } - puts "Status output:\n#{output}" - assert output.include? 'SOURCE' - assert output.include? 'SINK' - end - - define_test 'Get replication source metrics information' do - output = capture_stdout { replication_status('replication', 'source') } - puts "Status output:\n#{output}" - assert output.include? 'SOURCE' - end - - define_test 'Get replication sink metrics information' do - output = capture_stdout { replication_status('replication', 'sink') } - puts "Status output:\n#{output}" - assert output.include? 'SINK' - end - - define_test 'Get simple status' do - output = capture_stdout { admin.status('simple', '') } - puts "Status output:\n#{output}" - assert output.include? 'active master' - end - - define_test 'Get detailed status' do - output = capture_stdout { admin.status('detailed', '') } - puts "Status output:\n#{output}" - # Some text which isn't in the simple output - assert output.include? 'regionsInTransition' - end - end - - # Simple administration methods tests - # rubocop:disable ClassLength - class AdminSnapshotTest < Test::Unit::TestCase - include TestHelpers - - def setup - setup_hbase - # Create test table if it does not exist - @test_name = "hbase_shell_tests_table" - drop_test_table(@test_name) - create_test_table(@test_name) - #Test snapshot name - @create_test_snapshot = 'hbase_shell_tests_snapshot' - end - - def teardown - shutdown - end - - #------------------------------------------------------------------------------- - define_test "Snapshot should fail with non-string table name" do - assert_raise(ArgumentError) do - command(:snapshot, 123, 'xxx') - end - end - - define_test "Snapshot should fail with non-string snapshot name" do - assert_raise(ArgumentError) do - command(:snapshot, @test_name, 123) - end - end - - define_test "Snapshot should fail without snapshot name" do - assert_raise(ArgumentError) do - command(:snapshot, @test_name) - end - end - - define_test "Snapshot should work with string args" do - drop_test_snapshot() - command(:snapshot, @test_name, @create_test_snapshot) - list = command(:list_snapshots, @create_test_snapshot) - assert_equal(1, list.size) - end - - define_test "Snapshot should work when SKIP_FLUSH args" do - drop_test_snapshot() - command(:snapshot, @test_name, @create_test_snapshot, {SKIP_FLUSH => true}) - list = command(:list_snapshots, @create_test_snapshot) - assert_equal(1, list.size) - end - - define_test "List snapshot without any args" do - drop_test_snapshot() - command(:snapshot, @test_name, @create_test_snapshot) - list = command(:list_snapshots) - assert_equal(1, list.size) - end - - define_test "List snapshot for a non-existing snapshot" do - list = command(:list_snapshots, "xyz") - assert_equal(0, list.size) - end - - define_test "Restore snapshot without any args" do - assert_raise(ArgumentError) do - command(:restore_snapshot) - end - end - - define_test 'Restore snapshot should work' do - drop_test_snapshot - restore_table = 'test_restore_snapshot_table' - command(:create, restore_table, 'f1', 'f2') - assert_match(/f1/, admin.describe(restore_table)) - assert_match(/f2/, admin.describe(restore_table)) - command(:snapshot, restore_table, @create_test_snapshot) - command(:alter, restore_table, METHOD => 'delete', NAME => 'f1') - assert_no_match(/f1/, admin.describe(restore_table)) - assert_match(/f2/, admin.describe(restore_table)) - drop_test_table(restore_table) - command(:restore_snapshot, @create_test_snapshot) - assert_match(/f1/, admin.describe(restore_table)) - assert_match(/f2/, admin.describe(restore_table)) - drop_test_table(restore_table) - end - - define_test 'Restore snapshot should fail' do - drop_test_snapshot - restore_table = 'test_restore_snapshot_table' - command(:create, restore_table, 'f1', 'f2') - assert_match(/f1/, admin.describe(restore_table)) - assert_match(/f2/, admin.describe(restore_table)) - command(:snapshot, restore_table, @create_test_snapshot) - assert_raise(RuntimeError) do - command(:restore_snapshot, @create_test_snapshot) - end - drop_test_table(restore_table) - end - - define_test "Clone snapshot without any args" do - assert_raise(ArgumentError) do - command(:restore_snapshot) - end - end - - define_test "Clone snapshot without table name args" do - assert_raise(ArgumentError) do - command(:clone_snapshot, @create_test_snapshot) - end - end - - define_test "Clone snapshot should work" do - drop_test_snapshot() - clone_table = "test_clone_snapshot_table" - assert_match(eval("/" + "x" + "/"), admin.describe(@test_name)) - assert_match(eval("/" + "y" + "/"), admin.describe(@test_name)) - command(:snapshot, @test_name, @create_test_snapshot) - command(:clone_snapshot, @create_test_snapshot, clone_table) - assert_match(eval("/" + "x" + "/"), admin.describe(clone_table)) - assert_match(eval("/" + "y" + "/"), admin.describe(clone_table)) - drop_test_table(clone_table) - end - - define_test "Delete snapshot without any args" do - assert_raise(ArgumentError) do - admin.delete_snapshot() - end - end - - define_test "Delete snapshot should work" do - drop_test_snapshot() - command(:snapshot, @test_name, @create_test_snapshot) - list = command(:list_snapshots) - assert_equal(1, list.size) - admin.delete_snapshot(@create_test_snapshot) - list = command(:list_snapshots) - assert_equal(0, list.size) - end - - define_test "Delete all snapshots without any args" do - assert_raise(ArgumentError) do - admin.delete_all_snapshot() - end - end - - define_test "Delete all snapshots should work" do - drop_test_snapshot() - command(:snapshot, @test_name, "delete_all_snapshot1") - command(:snapshot, @test_name, "delete_all_snapshot2") - command(:snapshot, @test_name, "snapshot_delete_all_1") - command(:snapshot, @test_name, "snapshot_delete_all_2") - list = command(:list_snapshots) - assert_equal(4, list.size) - admin.delete_all_snapshot("d.*") - list = command(:list_snapshots) - assert_equal(2, list.size) - admin.delete_all_snapshot(".*") - list = command(:list_snapshots) - assert_equal(0, list.size) - end - - define_test "Delete table snapshots without any args" do - assert_raise(ArgumentError) do - admin.delete_table_snapshots() - end - end - - define_test "Delete table snapshots should work" do - drop_test_snapshot() - command(:snapshot, @test_name, "delete_table_snapshot1") - command(:snapshot, @test_name, "delete_table_snapshot2") - command(:snapshot, @test_name, "snapshot_delete_table1") - new_table = "test_delete_table_snapshots_table" - command(:create, new_table, 'f1') - command(:snapshot, new_table, "delete_table_snapshot3") - list = command(:list_snapshots) - assert_equal(4, list.size) - admin.delete_table_snapshots(@test_name, "d.*") - list = command(:list_snapshots) - assert_equal(2, list.size) - admin.delete_table_snapshots(@test_name) - list = command(:list_snapshots) - assert_equal(1, list.size) - admin.delete_table_snapshots(".*", "d.*") - list = command(:list_snapshots) - assert_equal(0, list.size) - drop_test_table(new_table) - end - - define_test "List table snapshots without any args" do - assert_raise(ArgumentError) do - command(:list_table_snapshots) - end - end - - define_test "List table snapshots should work" do - drop_test_snapshot() - command(:snapshot, @test_name, "delete_table_snapshot1") - command(:snapshot, @test_name, "delete_table_snapshot2") - command(:snapshot, @test_name, "snapshot_delete_table1") - new_table = "test_list_table_snapshots_table" - command(:create, new_table, 'f1') - command(:snapshot, new_table, "delete_table_snapshot3") - list = command(:list_table_snapshots, ".*") - assert_equal(4, list.size) - list = command(:list_table_snapshots, @test_name, "d.*") - assert_equal(2, list.size) - list = command(:list_table_snapshots, @test_name) - assert_equal(3, list.size) - admin.delete_table_snapshots(".*") - list = command(:list_table_snapshots, ".*", ".*") - assert_equal(0, list.size) - drop_test_table(new_table) - end - end - # rubocop:enable ClassLength end diff --git a/hbase-shell/src/test/ruby/hbase/table_test.rb b/hbase-shell/src/test/ruby/hbase/table_test.rb index 9b15f839f9e3..5ec317a88b0a 100644 --- a/hbase-shell/src/test/ruby/hbase/table_test.rb +++ b/hbase-shell/src/test/ruby/hbase/table_test.rb @@ -437,6 +437,21 @@ def teardown end end + define_test 'get should work with a custom converter class' do + @test_table.put(1, 'x:v', 1234) + begin + res = @test_table._get_internal('1', 'COLUMNS' => + ['x:v:c(org.apache.hadoop.hbase.util.Bytes).len']) + assert_not_nil(res) + assert_kind_of(Hash, res) + assert_not_nil(res['x:v']) + assert_not_nil(/value=4/.match(res['x:v'])) + ensure + # clean up newly added columns for this test only. + @test_table.deleteall(1, 'x:v') + end + end + #------------------------------------------------------------------------------- define_test "scan should work w/o any params" do @@ -679,6 +694,21 @@ def teardown assert_not_nil(res) end + define_test 'scan should work with a custom converter class' do + @test_table.put(1, 'x:v', 1234) + begin + res = @test_table._scan_internal 'COLUMNS' => + ['x:v:c(org.apache.hadoop.hbase.util.Bytes).len'] + assert_not_nil(res) + assert_kind_of(Hash, res) + assert_not_nil(res['1']['x:v']) + assert_not_nil(/value=4/.match(res['1']['x:v'])) + ensure + # clean up newly added columns for this test only. + @test_table.deleteall(1, 'x:v') + end + end + define_test "mutation with TTL should expire" do @test_table.put('ttlTest', 'x:a', 'foo', { TTL => 1000 } ) begin diff --git a/hbase-shell/src/test/ruby/shell/shell_test.rb b/hbase-shell/src/test/ruby/shell/shell_test.rb index 593e5019a73f..e7f5b2639ceb 100644 --- a/hbase-shell/src/test/ruby/shell/shell_test.rb +++ b/hbase-shell/src/test/ruby/shell/shell_test.rb @@ -85,9 +85,9 @@ module Foo; end define_test "Shell::Shell interactive mode should not throw" do # incorrect number of arguments - @shell.command('create', 'foo') - @shell.command('create', 'foo', 'family_1') + @shell.command('create', 'nothrow_table') + @shell.command('create', 'nothrow_table', 'family_1') # create a table that exists - @shell.command('create', 'foo', 'family_1') + @shell.command('create', 'nothrow_table', 'family_1') end end diff --git a/hbase-spark/src/main/java/org/apache/hadoop/hbase/spark/SparkSQLPushDownFilter.java b/hbase-spark/src/main/java/org/apache/hadoop/hbase/spark/SparkSQLPushDownFilter.java index b1d0ba7e6228..a17d2e68fbbc 100644 --- a/hbase-spark/src/main/java/org/apache/hadoop/hbase/spark/SparkSQLPushDownFilter.java +++ b/hbase-spark/src/main/java/org/apache/hadoop/hbase/spark/SparkSQLPushDownFilter.java @@ -32,11 +32,11 @@ import org.apache.hadoop.hbase.filter.Filter.ReturnCode; import org.apache.hadoop.hbase.filter.FilterBase; import org.apache.hadoop.hbase.spark.datasources.BytesEncoder; +import org.apache.hadoop.hbase.spark.datasources.Field; import org.apache.hadoop.hbase.spark.datasources.JavaBytesEncoder; import org.apache.hadoop.hbase.spark.protobuf.generated.SparkFilterProtos; import org.apache.hadoop.hbase.util.ByteStringer; import org.apache.hadoop.hbase.util.Bytes; -import org.apache.spark.sql.datasources.hbase.Field; import org.apache.yetus.audience.InterfaceAudience; import org.slf4j.Logger; import org.slf4j.LoggerFactory; diff --git a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DefaultSource.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DefaultSource.scala index 9e139540e5b0..4e05695fc795 100644 --- a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DefaultSource.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DefaultSource.scala @@ -34,7 +34,6 @@ import org.apache.hadoop.hbase.TableName import org.apache.hadoop.hbase.CellUtil import org.apache.hadoop.mapred.JobConf import org.apache.spark.rdd.RDD -import org.apache.spark.sql.datasources.hbase.{Utils, Field, HBaseTableCatalog} import org.apache.spark.sql.{DataFrame, SaveMode, Row, SQLContext} import org.apache.spark.sql.sources._ import org.apache.spark.sql.types._ diff --git a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DynamicLogicExpression.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DynamicLogicExpression.scala index 283838f52b10..4c35a7b4e2a2 100644 --- a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DynamicLogicExpression.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/DynamicLogicExpression.scala @@ -23,8 +23,7 @@ import org.apache.yetus.audience.InterfaceAudience; import org.apache.hadoop.hbase.spark.datasources.{BytesEncoder, JavaBytesEncoder} import org.apache.hadoop.hbase.spark.datasources.JavaBytesEncoder.JavaBytesEncoder import org.apache.hadoop.hbase.util.Bytes -import org.apache.spark.sql.datasources.hbase.{Field, Utils} -import org.apache.spark.sql.types._ + /** * Dynamic logic for SQL push down logic there is an instance for most * common operations and a pass through for other operations not covered here diff --git a/hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/DataTypeParserWrapper.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/DataTypeParserWrapper.scala similarity index 96% rename from hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/DataTypeParserWrapper.scala rename to hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/DataTypeParserWrapper.scala index 430785222a6a..c0ccc9288266 100644 --- a/hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/DataTypeParserWrapper.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/DataTypeParserWrapper.scala @@ -15,7 +15,7 @@ * limitations under the License. */ -package org.apache.spark.sql.datasources.hbase +package org.apache.hadoop.hbase.spark.datasources import org.apache.spark.sql.catalyst.parser.CatalystSqlParser import org.apache.spark.sql.types.DataType diff --git a/hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/HBaseTableCatalog.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableCatalog.scala similarity index 97% rename from hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/HBaseTableCatalog.scala rename to hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableCatalog.scala index 6cb0b187062f..d2a8a3e84534 100644 --- a/hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/HBaseTableCatalog.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableCatalog.scala @@ -15,21 +15,17 @@ * limitations under the License. */ -package org.apache.spark.sql.datasources.hbase +package org.apache.hadoop.hbase.spark.datasources import org.apache.avro.Schema -import org.apache.yetus.audience.InterfaceAudience; -import org.apache.hadoop.hbase.spark.Logging -import org.apache.hadoop.hbase.spark.SchemaConverters -import org.apache.hadoop.hbase.spark.datasources._ -import org.apache.hadoop.hbase.spark.hbase._ +import org.apache.yetus.audience.InterfaceAudience +import org.apache.hadoop.hbase.spark.{Logging, SchemaConverters} import org.apache.hadoop.hbase.util.Bytes import org.apache.spark.sql.types._ import org.json4s.jackson.JsonMethods._ import scala.collection.mutable -// Due the access issue defined in spark, we have to locate the file in this package. // The definition of each column cell, which may be composite type // TODO: add avro support @InterfaceAudience.Private diff --git a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableScanRDD.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableScanRDD.scala index 6a656677e1a1..6c06811d123f 100644 --- a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableScanRDD.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/HBaseTableScanRDD.scala @@ -25,7 +25,6 @@ import org.apache.hadoop.hbase.spark._ import org.apache.hadoop.hbase.spark.hbase._ import org.apache.hadoop.hbase.spark.datasources.HBaseResources._ import org.apache.hadoop.hbase.util.ShutdownHookManager -import org.apache.spark.sql.datasources.hbase.Field import org.apache.spark.{SparkEnv, TaskContext, Partition} import org.apache.spark.rdd.RDD diff --git a/hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/Utils.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/Utils.scala similarity index 98% rename from hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/Utils.scala rename to hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/Utils.scala index 5db5965f6141..093c6ac04e8c 100644 --- a/hbase-spark/src/main/scala/org/apache/spark/sql/datasources/hbase/Utils.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/datasources/Utils.scala @@ -16,7 +16,7 @@ * limitations under the License. */ -package org.apache.spark.sql.datasources.hbase +package org.apache.hadoop.hbase.spark.datasources import org.apache.hadoop.hbase.spark.AvroSerdes import org.apache.hadoop.hbase.util.Bytes diff --git a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/AvroSource.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/AvroSource.scala index fda3c785ea38..068b1af6aca9 100644 --- a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/AvroSource.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/AvroSource.scala @@ -20,7 +20,7 @@ package org.apache.hadoop.hbase.spark.example.datasources import org.apache.avro.Schema import org.apache.avro.generic.GenericData import org.apache.hadoop.hbase.spark.AvroSerdes -import org.apache.spark.sql.datasources.hbase.HBaseTableCatalog +import org.apache.hadoop.hbase.spark.datasources.HBaseTableCatalog import org.apache.spark.sql.DataFrame import org.apache.spark.sql.SQLContext import org.apache.spark.SparkConf diff --git a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/DataType.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/DataType.scala index 06303716af91..ac7e7766de3b 100644 --- a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/DataType.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/DataType.scala @@ -17,7 +17,7 @@ package org.apache.hadoop.hbase.spark.example.datasources -import org.apache.spark.sql.datasources.hbase.HBaseTableCatalog +import org.apache.hadoop.hbase.spark.datasources.HBaseTableCatalog import org.apache.spark.sql.DataFrame import org.apache.spark.sql.SQLContext import org.apache.spark.SparkConf diff --git a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/HBaseSource.scala b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/HBaseSource.scala index b414a379f5fb..6accae09253d 100644 --- a/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/HBaseSource.scala +++ b/hbase-spark/src/main/scala/org/apache/hadoop/hbase/spark/example/datasources/HBaseSource.scala @@ -17,7 +17,7 @@ package org.apache.hadoop.hbase.spark.example.datasources -import org.apache.spark.sql.datasources.hbase.HBaseTableCatalog +import org.apache.hadoop.hbase.spark.datasources.HBaseTableCatalog import org.apache.spark.sql.DataFrame import org.apache.spark.sql.SQLContext import org.apache.spark.SparkConf diff --git a/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/DefaultSourceSuite.scala b/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/DefaultSourceSuite.scala index 89b68f4cde24..afe515bce9d9 100644 --- a/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/DefaultSourceSuite.scala +++ b/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/DefaultSourceSuite.scala @@ -20,10 +20,9 @@ package org.apache.hadoop.hbase.spark import org.apache.avro.Schema import org.apache.avro.generic.GenericData import org.apache.hadoop.hbase.client.{ConnectionFactory, Put} -import org.apache.hadoop.hbase.spark.datasources.HBaseSparkConf +import org.apache.hadoop.hbase.spark.datasources.{HBaseSparkConf, HBaseTableCatalog} import org.apache.hadoop.hbase.util.Bytes import org.apache.hadoop.hbase.{HBaseTestingUtility, TableName} -import org.apache.spark.sql.datasources.hbase.HBaseTableCatalog import org.apache.spark.sql.functions._ import org.apache.spark.sql.{DataFrame, SQLContext} import org.apache.spark.{SparkConf, SparkContext} diff --git a/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/HBaseCatalogSuite.scala b/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/HBaseCatalogSuite.scala index d8af4a8791c6..74bf912cc87f 100644 --- a/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/HBaseCatalogSuite.scala +++ b/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/HBaseCatalogSuite.scala @@ -17,9 +17,8 @@ package org.apache.hadoop.hbase.spark -import org.apache.hadoop.hbase.spark.datasources.{DoubleSerDes, SerDes} +import org.apache.hadoop.hbase.spark.datasources.{DataTypeParserWrapper, DoubleSerDes, HBaseTableCatalog} import org.apache.hadoop.hbase.util.Bytes -import org.apache.spark.sql.datasources.hbase.{DataTypeParserWrapper, HBaseTableCatalog} import org.apache.spark.sql.types._ import org.scalatest.{BeforeAndAfterAll, BeforeAndAfterEach, FunSuite} diff --git a/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/PartitionFilterSuite.scala b/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/PartitionFilterSuite.scala index 034d450615af..496008473fe4 100644 --- a/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/PartitionFilterSuite.scala +++ b/hbase-spark/src/test/scala/org/apache/hadoop/hbase/spark/PartitionFilterSuite.scala @@ -17,9 +17,8 @@ package org.apache.hadoop.hbase.spark -import org.apache.hadoop.hbase.spark.datasources.HBaseSparkConf -import org.apache.hadoop.hbase.{TableName, HBaseTestingUtility} -import org.apache.spark.sql.datasources.hbase.HBaseTableCatalog +import org.apache.hadoop.hbase.spark.datasources.{HBaseSparkConf, HBaseTableCatalog} +import org.apache.hadoop.hbase.{HBaseTestingUtility, TableName} import org.apache.spark.sql.{DataFrame, SQLContext} import org.apache.spark.{SparkConf, SparkContext} import org.scalatest.{BeforeAndAfterAll, BeforeAndAfterEach, FunSuite} diff --git a/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MasterMaintenanceModeTracker.java b/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MasterMaintenanceModeTracker.java index 9dafe5fede35..fc9462ac1017 100644 --- a/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MasterMaintenanceModeTracker.java +++ b/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MasterMaintenanceModeTracker.java @@ -25,6 +25,10 @@ /** * Tracks the master Maintenance Mode via ZK. + * + * Unused. Used to be set by hbck to prevent concurrent splits/merges, but those use PV2 now and + * HBCK2 uses it's own service, so no longer an issue. Left in, in case we need to use this for + * the incomplete parts of HBCK2... */ @InterfaceAudience.Private public class MasterMaintenanceModeTracker extends ZKListener { diff --git a/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MiniZooKeeperCluster.java b/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MiniZooKeeperCluster.java index b2645639ccec..730d0dd4cc2d 100644 --- a/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MiniZooKeeperCluster.java +++ b/hbase-zookeeper/src/main/java/org/apache/hadoop/hbase/zookeeper/MiniZooKeeperCluster.java @@ -176,6 +176,8 @@ private static void setupTestEnv() { // set env and directly in order to handle static init/gc issues System.setProperty("zookeeper.preAllocSize", "100"); FileTxnLog.setPreallocSize(100 * 1024); + // allow all 4 letter words + System.setProperty("zookeeper.4lw.commands.whitelist","*"); } public int startup(File baseDir) throws IOException, InterruptedException { diff --git a/pom.xml b/pom.xml index bd0cea67cde0..ffa0a52bacbf 100755 --- a/pom.xml +++ b/pom.xml @@ -452,6 +452,12 @@ mdrob@apache.org -5 + + meszibalu + Balazs Meszaros + meszibalu@apache.org + +1 + misty Misty Stanley-Jones @@ -942,6 +948,7 @@ **/src/main/asciidoc/hbase.css **/jquery.min.js + **/jquery.tablesorter.min.js **/*.vm @@ -1485,7 +1492,7 @@ 3.2.1 2.9.2 2.2.12 - 9.3.19.v20170502 + 9.3.25.v20180904 3.1.0 2.0.1 @@ -1515,7 +1522,7 @@ 2.1.11 1.0.18 2.12.2 - 1.46 + 1.60 1.0.1 1.0.0 4.0.0 @@ -2192,7 +2199,7 @@ org.bouncycastle - bcprov-jdk16 + bcprov-jdk15on ${bouncycastle.version} test @@ -2960,6 +2967,10 @@ com.google.guava guava + + net.minidev + json-smart + diff --git a/src/main/asciidoc/_chapters/hbck_in_depth.adoc b/src/main/asciidoc/_chapters/hbck_in_depth.adoc deleted file mode 100644 index 1e1f9fb44070..000000000000 --- a/src/main/asciidoc/_chapters/hbck_in_depth.adoc +++ /dev/null @@ -1,212 +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. - */ -//// - -[appendix] -[[hbck.in.depth]] -== hbck In Depth -:doctype: book -:numbered: -:toc: left -:icons: font -:experimental: - -HBaseFsck (hbck) is a tool for checking for region consistency and table integrity problems and repairing a corrupted HBase. -It works in two basic modes -- a read-only inconsistency identifying mode and a multi-phase read-write repair mode. - -=== Running hbck to identify inconsistencies - -To check to see if your HBase cluster has corruptions, run hbck against your HBase cluster: - -[source,bourne] ----- - -$ ./bin/hbase hbck ----- - -At the end of the commands output it prints OK or tells you the number of INCONSISTENCIES present. -You may also want to run hbck a few times because some inconsistencies can be transient (e.g. -cluster is starting up or a region is splitting). Operationally you may want to run hbck regularly and setup alert (e.g. -via nagios) if it repeatedly reports inconsistencies . A run of hbck will report a list of inconsistencies along with a brief description of the regions and tables affected. -The using the `-details` option will report more details including a representative listing of all the splits present in all the tables. - -[source,bourne] ----- - -$ ./bin/hbase hbck -details ----- - -If you just want to know if some tables are corrupted, you can limit hbck to identify inconsistencies in only specific tables. -For example the following command would only attempt to check table TableFoo and TableBar. -The benefit is that hbck will run in less time. - -[source,bourne] ----- - -$ ./bin/hbase hbck TableFoo TableBar ----- - -=== Inconsistencies - -If after several runs, inconsistencies continue to be reported, you may have encountered a corruption. -These should be rare, but in the event they occur newer versions of HBase include the hbck tool enabled with automatic repair options. - -There are two invariants that when violated create inconsistencies in HBase: - -* HBase's region consistency invariant is satisfied if every region is assigned and deployed on exactly one region server, and all places where this state kept is in accordance. -* HBase's table integrity invariant is satisfied if for each table, every possible row key resolves to exactly one region. - -Repairs generally work in three phases -- a read-only information gathering phase that identifies inconsistencies, a table integrity repair phase that restores the table integrity invariant, and then finally a region consistency repair phase that restores the region consistency invariant. -Starting from version 0.90.0, hbck could detect region consistency problems report on a subset of possible table integrity problems. -It also included the ability to automatically fix the most common inconsistency, region assignment and deployment consistency problems. -This repair could be done by using the `-fix` command line option. -These problems close regions if they are open on the wrong server or on multiple region servers and also assigns regions to region servers if they are not open. - -Starting from HBase versions 0.90.7, 0.92.2 and 0.94.0, several new command line options are introduced to aid repairing a corrupted HBase. -This hbck sometimes goes by the nickname ``uberhbck''. Each particular version of uber hbck is compatible with the HBase's of the same major version (0.90.7 uberhbck can repair a 0.90.4). However, versions <=0.90.6 and versions <=0.92.1 may require restarting the master or failing over to a backup master. - -=== Localized repairs - -When repairing a corrupted HBase, it is best to repair the lowest risk inconsistencies first. -These are generally region consistency repairs -- localized single region repairs, that only modify in-memory data, ephemeral zookeeper data, or patch holes in the META table. -Region consistency requires that the HBase instance has the state of the region's data in HDFS (.regioninfo files), the region's row in the hbase:meta table., and region's deployment/assignments on region servers and the master in accordance. -Options for repairing region consistency include: - -* `-fixAssignments` (equivalent to the 0.90 `-fix` option) repairs unassigned, incorrectly assigned or multiply assigned regions. -* `-fixMeta` which removes meta rows when corresponding regions are not present in HDFS and adds new meta rows if they regions are present in HDFS while not in META. To fix deployment and assignment problems you can run this command: - -[source,bourne] ----- - -$ ./bin/hbase hbck -fixAssignments ----- - -To fix deployment and assignment problems as well as repairing incorrect meta rows you can run this command: - -[source,bourne] ----- - -$ ./bin/hbase hbck -fixAssignments -fixMeta ----- - -There are a few classes of table integrity problems that are low risk repairs. -The first two are degenerate (startkey == endkey) regions and backwards regions (startkey > endkey). These are automatically handled by sidelining the data to a temporary directory (/hbck/xxxx). The third low-risk class is hdfs region holes. -This can be repaired by using the: - -* `-fixHdfsHoles` option for fabricating new empty regions on the file system. - If holes are detected you can use -fixHdfsHoles and should include -fixMeta and -fixAssignments to make the new region consistent. - -[source,bourne] ----- - -$ ./bin/hbase hbck -fixAssignments -fixMeta -fixHdfsHoles ----- - -Since this is a common operation, we've added a the `-repairHoles` flag that is equivalent to the previous command: - -[source,bourne] ----- - -$ ./bin/hbase hbck -repairHoles ----- - -If inconsistencies still remain after these steps, you most likely have table integrity problems related to orphaned or overlapping regions. - -=== Region Overlap Repairs - -Table integrity problems can require repairs that deal with overlaps. -This is a riskier operation because it requires modifications to the file system, requires some decision making, and may require some manual steps. -For these repairs it is best to analyze the output of a `hbck -details` run so that you isolate repairs attempts only upon problems the checks identify. -Because this is riskier, there are safeguard that should be used to limit the scope of the repairs. -WARNING: This is a relatively new and have only been tested on online but idle HBase instances (no reads/writes). Use at your own risk in an active production environment! The options for repairing table integrity violations include: - -* `-fixHdfsOrphans` option for ``adopting'' a region directory that is missing a region metadata file (the .regioninfo file). -* `-fixHdfsOverlaps` ability for fixing overlapping regions - -When repairing overlapping regions, a region's data can be modified on the file system in two ways: 1) by merging regions into a larger region or 2) by sidelining regions by moving data to ``sideline'' directory where data could be restored later. -Merging a large number of regions is technically correct but could result in an extremely large region that requires series of costly compactions and splitting operations. -In these cases, it is probably better to sideline the regions that overlap with the most other regions (likely the largest ranges) so that merges can happen on a more reasonable scale. -Since these sidelined regions are already laid out in HBase's native directory and HFile format, they can be restored by using HBase's bulk load mechanism. -The default safeguard thresholds are conservative. -These options let you override the default thresholds and to enable the large region sidelining feature. - -* `-maxMerge ` maximum number of overlapping regions to merge -* `-sidelineBigOverlaps` if more than maxMerge regions are overlapping, sideline attempt to sideline the regions overlapping with the most other regions. -* `-maxOverlapsToSideline ` if sidelining large overlapping regions, sideline at most n regions. - -Since often times you would just want to get the tables repaired, you can use this option to turn on all repair options: - -* `-repair` includes all the region consistency options and only the hole repairing table integrity options. - -Finally, there are safeguards to limit repairs to only specific tables. -For example the following command would only attempt to check and repair table TableFoo and TableBar. - ----- - -$ ./bin/hbase hbck -repair TableFoo TableBar ----- - -==== Special cases: Meta is not properly assigned - -There are a few special cases that hbck can handle as well. -Sometimes the meta table's only region is inconsistently assigned or deployed. -In this case there is a special `-fixMetaOnly` option that can try to fix meta assignments. - ----- - -$ ./bin/hbase hbck -fixMetaOnly -fixAssignments ----- - -==== Special cases: HBase version file is missing - -HBase's data on the file system requires a version file in order to start. -If this file is missing, you can use the `-fixVersionFile` option to fabricating a new HBase version file. -This assumes that the version of hbck you are running is the appropriate version for the HBase cluster. - -==== Special case: Root and META are corrupt. - -The most drastic corruption scenario is the case where the ROOT or META is corrupted and HBase will not start. -In this case you can use the OfflineMetaRepair tool create new ROOT and META regions and tables. -This tool assumes that HBase is offline. -It then marches through the existing HBase home directory, loads as much information from region metadata files (.regioninfo files) as possible from the file system. -If the region metadata has proper table integrity, it sidelines the original root and meta table directories, and builds new ones with pointers to the region directories and their data. - ----- - -$ ./bin/hbase org.apache.hadoop.hbase.util.hbck.OfflineMetaRepair ----- - -NOTE: This tool is not as clever as uberhbck but can be used to bootstrap repairs that uberhbck can complete. -If the tool succeeds you should be able to start hbase and run online repairs if necessary. - -==== Special cases: Offline split parent - -Once a region is split, the offline parent will be cleaned up automatically. -Sometimes, daughter regions are split again before their parents are cleaned up. -HBase can clean up parents in the right order. -However, there could be some lingering offline split parents sometimes. -They are in META, in HDFS, and not deployed. -But HBase can't clean them up. -In this case, you can use the `-fixSplitParents` option to reset them in META to be online and not split. -Therefore, hbck can merge them with other regions if fixing overlapping regions option is used. - -This option should not normally be used, and it is not in `-fixAll`. - -:numbered: diff --git a/src/main/asciidoc/_chapters/ops_mgt.adoc b/src/main/asciidoc/_chapters/ops_mgt.adoc index 443d89549308..ae5507f4ce51 100644 --- a/src/main/asciidoc/_chapters/ops_mgt.adoc +++ b/src/main/asciidoc/_chapters/ops_mgt.adoc @@ -51,7 +51,8 @@ Options: Commands: Some commands take arguments. Pass no args or -h for usage. shell Run the HBase shell - hbck Run the hbase 'fsck' tool + hbck Run the HBase 'fsck' tool. Defaults read-only hbck1. + Pass '-j /path/to/HBCK2.jar' to run hbase-2.x HBCK2. snapshot Tool for managing snapshots wal Write-ahead-log analyzer hfile Store file analyzer @@ -82,45 +83,54 @@ Others, such as `hbase shell` (<>), `hbase upgrade` (<>), and === Canary -There is a Canary class can help users to canary-test the HBase cluster status, with every column-family for every regions or RegionServer's granularity. -To see the usage, use the `-help` parameter. - ----- -$ ${HBASE_HOME}/bin/hbase canary -help - -Usage: hbase canary [opts] [table1 [table2]...] | [regionserver1 [regionserver2]..] - where [opts] are: - -help Show this help and exit. - -regionserver replace the table argument to regionserver, - which means to enable regionserver mode - -allRegions Tries all regions on a regionserver, - only works in regionserver mode. - -zookeeper Tries to grab zookeeper.znode.parent - on each zookeeper instance - -daemon Continuous check at defined intervals. - -interval Interval between checks (sec) - -e Use table/regionserver as regular expression - which means the table/regionserver is regular expression pattern - -f stop whole program if first error occurs, default is true - -t timeout for a check, default is 600000 (millisecs) - -writeTableTimeout write timeout for the writeTable, default is 600000 (millisecs) - -readTableTimeouts =,=, ... comma-separated list of read timeouts per table (no spaces), default is 600000 (millisecs) - -writeSniffing enable the write sniffing in canary - -treatFailureAsError treats read / write failure as error - -writeTable The table used for write sniffing. Default is hbase:canary - -Dhbase.canary.read.raw.enabled= Use this flag to enable or disable raw scan during read canary test Default is false and raw is not enabled during scan - -D= assigning or override the configuration params +The Canary tool can help users "canary-test" the HBase cluster status. +The default "region mode" fetches a row from every column-family of every regions. +In "regionserver mode", the Canary tool will fetch a row from a random +region on each of the cluster's RegionServers. In "zookeeper mode", the +Canary will read the root znode on each member of the zookeeper ensemble. + +To see usage, pass the `-help` parameter (if you pass no +parameters, the Canary tool starts executing in the default +region "mode" fetching a row from every region in the cluster). + +---- +2018-10-16 13:11:27,037 INFO [main] tool.Canary: Execution thread count=16 +Usage: canary [OPTIONS] [ [ [ interval between checks in seconds + -e consider table/regionserver argument as regular expression + -f exit on first error; default=true + -failureAsError treat read/write failure as error + -t timeout for canary-test run; default=600000ms + -writeSniffing enable write sniffing + -writeTable the table used for write sniffing; default=hbase:canary + -writeTableTimeout timeout for writeTable; default=600000ms + -readTableTimeouts =,=,... + comma-separated list of table read timeouts (no spaces); + logs 'ERROR' if takes longer. default=600000ms + -permittedZookeeperFailures Ignore first N failures attempting to + connect to individual zookeeper nodes in ensemble + + -D= to assign or override configuration params + -Dhbase.canary.read.raw.enabled= Set to enable/disable raw scan; default=false + +Canary runs in one of three modes: region (default), regionserver, or zookeeper. +To sniff/probe all regions, pass no arguments. +To sniff/probe all regions of a table, pass tablename. +To sniff/probe regionservers, pass -regionserver, etc. +See http://hbase.apache.org/book.html#_canary for Canary documentation. ---- [NOTE] -The `Sink` class is instantiated using the `hbase.canary.sink.class` configuration property which -will also determine the used Monitor class. In the absence of this property RegionServerStdOutSink -will be used. You need to use the Sink according to the passed parameters to the _canary_ command. -As an example you have to set `hbase.canary.sink.class` property to -`org.apache.hadoop.hbase.tool.Canary$RegionStdOutSink` for using table parameters. +The `Sink` class is instantiated using the `hbase.canary.sink.class` configuration property. -This tool will return non zero error codes to user for collaborating with other monitoring tools, such as Nagios. -The error code definitions are: +This tool will return non zero error codes to user for collaborating with other monitoring tools, +such as Nagios. The error code definitions are: [source,java] ---- @@ -131,9 +141,9 @@ private static final int ERROR_EXIT_CODE = 4; private static final int FAILURE_EXIT_CODE = 5; ---- -Here are some examples based on the following given case. -There are two Table objects called test-01 and test-02, they have two column family cf1 and cf2 respectively, and deployed on the 3 RegionServers. -see following table. +Here are some examples based on the following given case: given two Table objects called test-01 +and test-02 each with two column family cf1 and cf2 respectively, deployed on 3 RegionServers. +See the following table. [cols="1,1,1", options="header"] |=== @@ -145,7 +155,7 @@ see following table. | rs3 | r2 | r1 |=== -Following are some examples based on the previous given case. +Following are some example outputs based on the previous given case. ==== Canary test for every column family (store) of every region of every table @@ -163,12 +173,13 @@ $ ${HBASE_HOME}/bin/hbase canary 13/12/09 03:26:32 INFO tool.Canary: read from region test-02,0004883,1386559511167.cbda32d5e2e276520712d84eaaa29d84. column family cf2 in 8ms ---- -So you can see, table test-01 has two regions and two column families, so the Canary tool will pick 4 small piece of data from 4 (2 region * 2 store) different stores. -This is a default behavior of the this tool does. +So you can see, table test-01 has two regions and two column families, so the Canary tool in the +default "region mode" will pick 4 small piece of data from 4 (2 region * 2 store) different stores. +This is a default behavior. -==== Canary test for every column family (store) of every region of specific table(s) +==== Canary test for every column family (store) of every region of a specific table(s) -You can also test one or more specific tables. +You can also test one or more specific tables by passing table names. ---- $ ${HBASE_HOME}/bin/hbase canary test-01 test-02 @@ -176,7 +187,9 @@ $ ${HBASE_HOME}/bin/hbase canary test-01 test-02 ==== Canary test with RegionServer granularity -This will pick one small piece of data from each RegionServer, and can also put your RegionServer name as input options for canary-test specific RegionServer. +In "regionserver mode", the Canary tool will pick one small piece of data +from each RegionServer (You can also pass one or more RegionServer names as arguments +to the canary-test when in "regionserver mode"). ---- $ ${HBASE_HOME}/bin/hbase canary -regionserver @@ -188,22 +201,25 @@ $ ${HBASE_HOME}/bin/hbase canary -regionserver ==== Canary test with regular expression pattern -This will test both table test-01 and test-02. +You can pass regexes for table names when in "region mode" or for servernames when +in "regionserver mode". The below will test both table test-01 and test-02. ---- $ ${HBASE_HOME}/bin/hbase canary -e test-0[1-2] ---- -==== Run canary test as daemon mode +==== Run canary test as a "daemon" -Run repeatedly with interval defined in option `-interval` whose default value is 60 seconds. -This daemon will stop itself and return non-zero error code if any error occurs, due to the default value of option -f is true. +Run repeatedly with an interval defined via the option `-interval` (default value is 60 seconds). +This daemon will stop itself and return non-zero error code if any error occur. To have +the daemon keep running across errors, pass the -f flag with its value set to false +(see usage above). ---- $ ${HBASE_HOME}/bin/hbase canary -daemon ---- -Run repeatedly with 5 second intervals and will not stop itself even if errors occur in the test. +To run repeatedly with 5 second intervals and not stop on errors, do the following. ---- $ ${HBASE_HOME}/bin/hbase canary -daemon -interval 5 -f false @@ -211,9 +227,11 @@ $ ${HBASE_HOME}/bin/hbase canary -daemon -interval 5 -f false ==== Force timeout if canary test stuck -In some cases the request is stuck and no response is sent back to the client. This can happen with dead RegionServers which the master has not yet noticed. -Because of this we provide a timeout option to kill the canary test and return a non-zero error code. -This run sets the timeout value to 60 seconds, the default value is 600 seconds. +In some cases the request is stuck and no response is sent back to the client. This +can happen with dead RegionServers which the master has not yet noticed. +Because of this we provide a timeout option to kill the canary test and return a +non-zero error code. The below sets the timeout value to 60 seconds (the default value +is 600 seconds). ---- $ ${HBASE_HOME}/bin/hbase canary -t 60000 @@ -221,36 +239,37 @@ $ ${HBASE_HOME}/bin/hbase canary -t 60000 ==== Enable write sniffing in canary -By default, the canary tool only check the read operations, it's hard to find the problem in the -write path. To enable the write sniffing, you can run canary with the `-writeSniffing` option. -When the write sniffing is enabled, the canary tool will create an hbase table and make sure the -regions of the table distributed on all region servers. In each sniffing period, the canary will -try to put data to these regions to check the write availability of each region server. +By default, the canary tool only checks read operations. To enable the write sniffing, +you can run the canary with the `-writeSniffing` option set. When write sniffing is +enabled, the canary tool will create an hbase table and make sure the +regions of the table are distributed to all region servers. In each sniffing period, +the canary will try to put data to these regions to check the write availability of +each region server. ---- $ ${HBASE_HOME}/bin/hbase canary -writeSniffing ---- -The default write table is `hbase:canary` and can be specified by the option `-writeTable`. +The default write table is `hbase:canary` and can be specified with the option `-writeTable`. ---- $ ${HBASE_HOME}/bin/hbase canary -writeSniffing -writeTable ns:canary ---- -The default value size of each put is 10 bytes and you can set it by the config key: +The default value size of each put is 10 bytes. You can set it via the config key: `hbase.canary.write.value.size`. ==== Treat read / write failure as error -By default, the canary tool only logs read failure, due to e.g. RetriesExhaustedException, -while returning normal exit code. To treat read / write failure as error, you can run canary -with the `-treatFailureAsError` option. When enabled, read / write failure would result in error -exit code. +By default, the canary tool only logs read failures -- due to e.g. RetriesExhaustedException, etc. -- +and will return the 'normal' exit code. To treat read/write failure as errors, you can run canary +with the `-treatFailureAsError` option. When enabled, read/write failures will result in an +error exit code. ---- $ ${HBASE_HOME}/bin/hbase canary -treatFailureAsError ---- ==== Running Canary in a Kerberos-enabled Cluster -To run Canary in a Kerberos-enabled cluster, configure the following two properties in _hbase-site.xml_: +To run the Canary in a Kerberos-enabled cluster, configure the following two properties in _hbase-site.xml_: * `hbase.client.keytab.file` * `hbase.client.kerberos.principal` @@ -368,12 +387,33 @@ Each command except `RowCounter` and `CellCounter` accept a single `--help` argu [[hbck]] === HBase `hbck` -To run `hbck` against your HBase cluster run `$./bin/hbase hbck`. At the end of the command's output it prints `OK` or `INCONSISTENCY`. -If your cluster reports inconsistencies, pass `-details` to see more detail emitted. -If inconsistencies, run `hbck` a few times because the inconsistency may be transient (e.g. cluster is starting up or a region is splitting). - Passing `-fix` may correct the inconsistency (This is an experimental feature). +The `hbck` tool that shipped with hbase-1.x has been made read-only in hbase-2.x. It is not able to repair +hbase-2.x clusters as hbase internals have changed. Nor should its assessments in read-only mode be +trusted as it does not understand hbase-2.x operation. -For more information, see <>. +A new tool, <>, described in the next section, replaces `hbck`. + +[[HBCK2]] +=== HBase `HBCK2` + +`HBCK2` is the successor to <>, the hbase-1.x fix tool (A.K.A `hbck1`). Use it in place of `hbck1` +making repairs against hbase-2.x installs. + +`HBCK2` does not ship as part of hbase. It can be found as a subproject of the companion +link:https://github.com/apache/hbase-operator-tools[hbase-operator-tools] repository at +link:https://github.com/apache/hbase-operator-tools/tree/master/hbase-hbck2[Apache HBase HBCK2 Tool]. +`HBCK2` was moved out of hbase so it could evolve at a cadence apart from that of hbase core. + +See the [https://github.com/apache/hbase-operator-tools/tree/master/hbase-hbck2](HBCK2) Home Page +for how `HBCK2` differs from `hbck1`, and for how to build and use it. + +Once built, you can run `HBCK2` as follows: + +``` +$ hbase hbck -j /path/to/HBCK2.jar +``` + +This will generate `HBCK2` usage describing commands and options. [[hfile_tool2]] === HFile Tool @@ -1254,15 +1294,6 @@ Monitor the output of the _/tmp/log.txt_ file to follow the progress of the scri Use the following guidelines if you want to create your own rolling restart script. . Extract the new release, verify its configuration, and synchronize it to all nodes of your cluster using `rsync`, `scp`, or another secure synchronization mechanism. -. Use the hbck utility to ensure that the cluster is consistent. -+ ----- - -$ ./bin/hbck ----- -+ -Perform repairs if required. -See <> for details. . Restart the master first. You may need to modify these commands if your new HBase directory is different from the old one, such as for an upgrade. @@ -1294,7 +1325,6 @@ $ for i in `cat conf/regionservers|sort`; do ./bin/graceful_stop.sh --restart -- ---- . Restart the Master again, to clear out the dead servers list and re-enable the load balancer. -. Run the `hbck` utility again, to be sure the cluster is consistent. [[adding.new.node]] === Adding a New Node @@ -2686,8 +2716,6 @@ HDFS replication factor only affects your disk usage and is invisible to most HB You can view the current number of regions for a given table using the HMaster UI. In the [label]#Tables# section, the number of online regions for each table is listed in the [label]#Online Regions# column. This total only includes the in-memory state and does not include disabled or offline regions. -If you do not want to use the HMaster UI, you can determine the number of regions by counting the number of subdirectories of the /hbase// subdirectories in HDFS, or by running the `bin/hbase hbck` command. -Each of these methods may return a slightly different number, depending on the status of each region. [[ops.capacity.regions.count]] ==== Number of regions per RS - upper bound diff --git a/src/main/asciidoc/_chapters/troubleshooting.adoc b/src/main/asciidoc/_chapters/troubleshooting.adoc index 8da3014f25a8..f5288be07b8b 100644 --- a/src/main/asciidoc/_chapters/troubleshooting.adoc +++ b/src/main/asciidoc/_chapters/troubleshooting.adoc @@ -311,6 +311,24 @@ The commands (and arguments) are: setquota -n|-b val path ---- +[[trouble.tools.maintenancemode]] +==== Maintenance Mode +If the cluster has gotten stuck in some state and the standard techniques aren't making progress, + it is possible to restart the cluster in "maintenance mode." This mode features drastically + reduced capabilities and surface area, making it easier to enact very low-level changes such + as repairing/recovering the `hbase:meta` table. + +To enter maintenance mode, set `hbase.master.maintenance_mode` to `true` either in your +`hbase-site.xml` or via system propery when starting the master process (`-D...=true`). Entering +and exiting this mode requires a service restart, however the typical use will be when HBase Master +is already facing startup difficulties. + +When maintenance mode is enabled, the master will host all system tables - ensure that it has +enough memory to do so. RegionServers will not be assigned any regions from user-space tables; +in fact, they will go completely unused while in maintenance mode. Additionally, the master will +not load any coprocessors, will not run any normalization or merge/split operations, and will not +enforce quotas. + [[trouble.tools.external]] === External Tools diff --git a/src/main/asciidoc/_chapters/upgrading.adoc b/src/main/asciidoc/_chapters/upgrading.adoc index a5561238420f..da0dac05f8be 100644 --- a/src/main/asciidoc/_chapters/upgrading.adoc +++ b/src/main/asciidoc/_chapters/upgrading.adoc @@ -331,7 +331,10 @@ As noted in the section <>, HBase 2.0+ requires a minimum o .HBCK must match HBase server version You *must not* use an HBase 1.x version of HBCK against an HBase 2.0+ cluster. HBCK is strongly tied to the HBase server version. Using the HBCK tool from an earlier release against an HBase 2.0+ cluster will destructively alter said cluster in unrecoverable ways. -As of HBase 2.0, HBCK is a read-only tool that can report the status of some non-public system internals. You should not rely on the format nor content of these internals to remain consistent across HBase releases. +As of HBase 2.0, HBCK (A.K.A _HBCK1_ or _hbck1_) is a read-only tool that can report the status of some non-public system internals. You should not rely on the format nor content of these internals to remain consistent across HBase releases. + +To read about HBCK's replacement, see <> in <>. + //// Link to a ref guide section on HBCK in 2.0 that explains use and calls out the inability of clients and server sides to detect version of each other. diff --git a/src/main/asciidoc/book.adoc b/src/main/asciidoc/book.adoc index db95b212d229..bd2692c631f2 100644 --- a/src/main/asciidoc/book.adoc +++ b/src/main/asciidoc/book.adoc @@ -86,7 +86,6 @@ include::_chapters/community.adoc[] include::_chapters/appendix_contributing_to_documentation.adoc[] include::_chapters/faq.adoc[] -include::_chapters/hbck_in_depth.adoc[] include::_chapters/appendix_acl_matrix.adoc[] include::_chapters/compression.adoc[] include::_chapters/sql.adoc[] diff --git a/src/site/site.xml b/src/site/site.xml index 907c06d11013..ebb7d8d0dabe 100644 --- a/src/site/site.xml +++ b/src/site/site.xml @@ -120,6 +120,10 @@ + + + + diff --git a/src/site/xdoc/downloads.xml b/src/site/xdoc/downloads.xml index 41375a00cab8..7edb387a58ac 100644 --- a/src/site/xdoc/downloads.xml +++ b/src/site/xdoc/downloads.xml @@ -87,23 +87,44 @@ under the License. + + + + + + + +
    - 1.2.7 + 1.4.8 - 2018/09/16 + 2018/10/08 - 1.2.6 vs 1.2.7 + 1.4.7 vs 1.4.8 - Changes + Changes - Release Notes + Release Notes - src (sha512 asc)
    - bin (sha512 asc) + src (sha512 asc)
    + bin (sha512 asc) +
    + 1.2.8 + + 2018/10/20 + + 1.2.7 vs 1.2.8 + + Changes + + Release Notes + + src (sha512 asc)
    + bin (sha512 asc)