diff --git a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java index 3c9738e..030c5a2 100644 --- a/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java +++ b/hbase-client/src/main/java/org/apache/hadoop/hbase/shaded/protobuf/ProtobufUtil.java @@ -1,4 +1,5 @@ /** + * * 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 @@ -2861,6 +2862,10 @@ public final class ProtobufUtil { return CompactionState.valueOf(state.toString()); } + public static GetRegionInfoResponse.CompactionState createCompactionState(CompactionState state) { + return GetRegionInfoResponse.CompactionState.valueOf(state.toString()); + } + public static Optional toOptionalTimestamp(MajorCompactionTimestampResponse resp) { long timestamp = resp.getCompactionTimestamp(); return timestamp == 0 ? Optional.empty() : Optional.of(timestamp); diff --git a/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/coprocessor/Export.java b/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/coprocessor/Export.java index 9b8901e..a549d91 100644 --- a/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/coprocessor/Export.java +++ b/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/coprocessor/Export.java @@ -58,6 +58,7 @@ import org.apache.hadoop.hbase.mapreduce.ResultSerialization; import org.apache.hadoop.hbase.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.protobuf.generated.ClientProtos.DelegationToken; import org.apache.hadoop.hbase.protobuf.generated.ExportProtos; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.InternalScanner; import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.RegionScanner; @@ -202,9 +203,9 @@ public class Export extends ExportProtos.ExportService implements RegionCoproces return rval; } - private static ExportProtos.ExportResponse processData(final Region region, final Configuration conf, - final UserProvider userProvider, final Scan scan, final Token userToken, - final List opts) throws IOException { + private static ExportProtos.ExportResponse processData(final HRegion region, + final Configuration conf, final UserProvider userProvider, final Scan scan, + final Token userToken, final List opts) throws IOException { ScanCoprocessor cp = new ScanCoprocessor(region); RegionScanner scanner = null; try (RegionOp regionOp = new RegionOp(region); @@ -318,7 +319,8 @@ public class Export extends ExportProtos.ExportService implements RegionCoproces @Override public void export(RpcController controller, ExportProtos.ExportRequest request, RpcCallback done) { - Region region = env.getRegion(); + assert env.getRegion() instanceof HRegion; + HRegion region = (HRegion) env.getRegion(); Configuration conf = HBaseConfiguration.create(env.getConfiguration()); conf.setStrings("io.serializations", conf.get("io.serializations"), ResultSerialization.class.getName()); try { @@ -360,9 +362,9 @@ public class Export extends ExportProtos.ExportService implements RegionCoproces private static class RegionOp implements Closeable { - private final Region region; + private final HRegion region; - RegionOp(final Region region) throws IOException { + RegionOp(final HRegion region) throws IOException { this.region = region; region.startRegionOperation(); } diff --git a/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/security/access/SecureBulkLoadEndpoint.java b/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/security/access/SecureBulkLoadEndpoint.java index 4286174..95bd302 100644 --- a/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/security/access/SecureBulkLoadEndpoint.java +++ b/hbase-endpoint/src/main/java/org/apache/hadoop/hbase/security/access/SecureBulkLoadEndpoint.java @@ -41,6 +41,7 @@ import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos.RegionSpecifier.Re import org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.SecureBulkLoadHFilesRequest; import org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.SecureBulkLoadHFilesResponse; import org.apache.hadoop.hbase.protobuf.generated.SecureBulkLoadProtos.SecureBulkLoadService; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.RegionServerServices; import org.apache.hadoop.hbase.regionserver.SecureBulkLoadManager; @@ -61,14 +62,16 @@ public class SecureBulkLoadEndpoint extends SecureBulkLoadService implements Reg private static final Log LOG = LogFactory.getLog(SecureBulkLoadEndpoint.class); - private RegionCoprocessorEnvironment env; private RegionServerServices rsServices; + private HRegion region; @Override - public void start(CoprocessorEnvironment env) { - this.env = (RegionCoprocessorEnvironment)env; - assert this.env.getCoprocessorRegionServerServices() instanceof RegionServerServices; - rsServices = (RegionServerServices) this.env.getCoprocessorRegionServerServices(); + public void start(CoprocessorEnvironment cpenv) { + RegionCoprocessorEnvironment env = (RegionCoprocessorEnvironment)cpenv; + assert env.getCoprocessorRegionServerServices() instanceof RegionServerServices; + rsServices = (RegionServerServices) env.getCoprocessorRegionServerServices(); + assert env.getRegion() instanceof HRegion; + this.region = (HRegion) env.getRegion(); LOG.warn("SecureBulkLoadEndpoint is deprecated. It will be removed in future releases."); LOG.warn("Secure bulk load has been integrated into HBase core."); } @@ -83,8 +86,7 @@ public class SecureBulkLoadEndpoint extends SecureBulkLoadService implements Reg try { SecureBulkLoadManager secureBulkLoadManager = this.rsServices.getSecureBulkLoadManager(); - String bulkToken = secureBulkLoadManager.prepareBulkLoad(this.env.getRegion(), - convert(request)); + String bulkToken = secureBulkLoadManager.prepareBulkLoad(this.region, convert(request)); done.run(PrepareBulkLoadResponse.newBuilder().setBulkToken(bulkToken).build()); } catch (IOException e) { CoprocessorRpcUtils.setControllerException(controller, e); @@ -109,7 +111,7 @@ public class SecureBulkLoadEndpoint extends SecureBulkLoadService implements Reg RpcCallback done) { try { SecureBulkLoadManager secureBulkLoadManager = this.rsServices.getSecureBulkLoadManager(); - secureBulkLoadManager.cleanupBulkLoad(this.env.getRegion(), convert(request)); + secureBulkLoadManager.cleanupBulkLoad(this.region, convert(request)); done.run(CleanupBulkLoadResponse.newBuilder().build()); } catch (IOException e) { CoprocessorRpcUtils.setControllerException(controller, e); @@ -141,8 +143,7 @@ public class SecureBulkLoadEndpoint extends SecureBulkLoadService implements Reg try { SecureBulkLoadManager secureBulkLoadManager = this.rsServices.getSecureBulkLoadManager(); BulkLoadHFileRequest bulkLoadHFileRequest = ConvertSecureBulkLoadHFilesRequest(request); - map = secureBulkLoadManager.secureBulkLoadHFiles(this.env.getRegion(), - convert(bulkLoadHFileRequest)); + map = secureBulkLoadManager.secureBulkLoadHFiles(this.region, convert(bulkLoadHFileRequest)); loaded = map != null && !map.isEmpty(); } catch (IOException e) { CoprocessorRpcUtils.setControllerException(controller, e); @@ -165,9 +166,8 @@ public class SecureBulkLoadEndpoint extends SecureBulkLoadService implements Reg private BulkLoadHFileRequest ConvertSecureBulkLoadHFilesRequest( SecureBulkLoadHFilesRequest request) { BulkLoadHFileRequest.Builder bulkLoadHFileRequest = BulkLoadHFileRequest.newBuilder(); - RegionSpecifier region = - ProtobufUtil.buildRegionSpecifier(RegionSpecifierType.REGION_NAME, this.env - .getRegionInfo().getRegionName()); + RegionSpecifier region = ProtobufUtil.buildRegionSpecifier(RegionSpecifierType.REGION_NAME, + this.region.getRegionInfo().getRegionName()); bulkLoadHFileRequest.setRegion(region).setFsToken(request.getFsToken()) .setBulkToken(request.getBulkToken()).setAssignSeqNum(request.getAssignSeqNum()) .addAllFamilyPath(request.getFamilyPathList()); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/coordination/ZkSplitLogWorkerCoordination.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/coordination/ZkSplitLogWorkerCoordination.java index 79c82f6..230a42f 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/coordination/ZkSplitLogWorkerCoordination.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/coordination/ZkSplitLogWorkerCoordination.java @@ -41,7 +41,7 @@ import org.apache.yetus.audience.InterfaceAudience; import org.apache.hadoop.hbase.exceptions.DeserializationException; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds; import org.apache.hadoop.hbase.shaded.protobuf.generated.ZooKeeperProtos.SplitLogTask.RecoveryMode; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.RegionServerServices; import org.apache.hadoop.hbase.regionserver.SplitLogWorker; import org.apache.hadoop.hbase.regionserver.SplitLogWorker.TaskExecutor; @@ -446,7 +446,7 @@ public class ZkSplitLogWorkerCoordination extends ZooKeeperListener implements taskReadyLock.wait(checkInterval); if (server != null) { // check to see if we have stale recovering regions in our internal memory state - Map recoveringRegions = server.getRecoveringRegions(); + Map recoveringRegions = server.getRecoveringRegions(); if (!recoveringRegions.isEmpty()) { // Make a local copy to prevent ConcurrentModificationException when other threads // modify recoveringRegions diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/FlushTableSubprocedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/FlushTableSubprocedure.java index 145bc14..8f9775d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/FlushTableSubprocedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/FlushTableSubprocedure.java @@ -28,7 +28,7 @@ import org.apache.hadoop.hbase.errorhandling.ForeignExceptionDispatcher; import org.apache.hadoop.hbase.procedure.ProcedureMember; import org.apache.hadoop.hbase.procedure.Subprocedure; import org.apache.hadoop.hbase.procedure.flush.RegionServerFlushTableProcedureManager.FlushTableSubprocedurePool; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; /** * This flush region implementation uses the distributed procedure framework to flush @@ -40,22 +40,22 @@ public class FlushTableSubprocedure extends Subprocedure { private static final Log LOG = LogFactory.getLog(FlushTableSubprocedure.class); private final String table; - private final List regions; + private final List regions; private final FlushTableSubprocedurePool taskManager; public FlushTableSubprocedure(ProcedureMember member, ForeignExceptionDispatcher errorListener, long wakeFrequency, long timeout, - List regions, String table, + List involvedRegions, String table, FlushTableSubprocedurePool taskManager) { super(member, table, errorListener, wakeFrequency, timeout); this.table = table; - this.regions = regions; + this.regions = involvedRegions; this.taskManager = taskManager; } private static class RegionFlushTask implements Callable { - Region region; - RegionFlushTask(Region region) { + HRegion region; + RegionFlushTask(HRegion region) { this.region = region; } @@ -90,7 +90,7 @@ public class FlushTableSubprocedure extends Subprocedure { } // Add all hfiles already existing in region. - for (Region region : regions) { + for (HRegion region : regions) { // submit one task per region for parallelize by region. taskManager.submitTask(new RegionFlushTask(region)); monitor.rethrowException(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/RegionServerFlushTableProcedureManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/RegionServerFlushTableProcedureManager.java index 49192e1..d4461bb 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/RegionServerFlushTableProcedureManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/procedure/flush/RegionServerFlushTableProcedureManager.java @@ -46,8 +46,8 @@ import org.apache.hadoop.hbase.procedure.RegionServerProcedureManager; import org.apache.hadoop.hbase.procedure.Subprocedure; import org.apache.hadoop.hbase.procedure.SubprocedureFactory; import org.apache.hadoop.hbase.procedure.ZKProcedureMemberRpcs; +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.regionserver.RegionServerServices; import org.apache.hadoop.hbase.zookeeper.ZooKeeperWatcher; import org.apache.zookeeper.KeeperException; @@ -139,7 +139,7 @@ public class RegionServerFlushTableProcedureManager extends RegionServerProcedur } // check to see if this server is hosting any regions for the table - List involvedRegions; + List involvedRegions; try { involvedRegions = getRegionsToFlush(table); } catch (IOException e1) { @@ -174,8 +174,8 @@ public class RegionServerFlushTableProcedureManager extends RegionServerProcedur * @return the list of online regions. Empty list is returned if no regions. * @throws IOException */ - private List getRegionsToFlush(String table) throws IOException { - return rss.getRegions(TableName.valueOf(table)); + private List getRegionsToFlush(String table) throws IOException { + return (List) rss.getRegions(TableName.valueOf(table)); } public class FlushTableSubprocedureBuilder implements SubprocedureFactory { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java index 3c9e972..af60aed 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/ActivePolicyEnforcement.java @@ -24,7 +24,7 @@ import java.util.Objects; import org.apache.hadoop.hbase.TableName; import org.apache.yetus.audience.InterfaceAudience; import org.apache.yetus.audience.InterfaceStability; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.RegionServerServices; /** @@ -68,7 +68,7 @@ public class ActivePolicyEnforcement { * * @see #getPolicyEnforcement(TableName) */ - public SpaceViolationPolicyEnforcement getPolicyEnforcement(Region r) { + public SpaceViolationPolicyEnforcement getPolicyEnforcement(HRegion r) { return getPolicyEnforcement(Objects.requireNonNull(r).getTableDescriptor().getTableName()); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java index f51e605..2434f21 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/quotas/RegionServerRpcQuotaManager.java @@ -29,7 +29,7 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.ipc.RpcScheduler; import org.apache.hadoop.hbase.ipc.RpcServer; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.RegionServerServices; import org.apache.hadoop.hbase.security.User; import org.apache.hadoop.security.UserGroupInformation; @@ -129,7 +129,7 @@ public class RegionServerRpcQuotaManager { * @return the OperationQuota * @throws ThrottlingException if the operation cannot be executed due to quota exceeded. */ - public OperationQuota checkQuota(final Region region, + public OperationQuota checkQuota(final HRegion region, final OperationQuota.OperationType type) throws IOException, ThrottlingException { switch (type) { case SCAN: return checkQuota(region, 0, 0, 1); @@ -148,7 +148,7 @@ public class RegionServerRpcQuotaManager { * @return the OperationQuota * @throws ThrottlingException if the operation cannot be executed due to quota exceeded. */ - public OperationQuota checkQuota(final Region region, + public OperationQuota checkQuota(final HRegion region, final List actions) throws IOException, ThrottlingException { int numWrites = 0; int numReads = 0; @@ -173,7 +173,7 @@ public class RegionServerRpcQuotaManager { * @return the OperationQuota * @throws ThrottlingException if the operation cannot be executed due to quota exceeded. */ - private OperationQuota checkQuota(final Region region, + private OperationQuota checkQuota(final HRegion region, final int numWrites, final int numReads, final int numScans) throws IOException, ThrottlingException { User user = RpcServer.getRequestUser(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/AnnotationReadingPriorityFunction.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/AnnotationReadingPriorityFunction.java index 377b685..bb972fd 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/AnnotationReadingPriorityFunction.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/AnnotationReadingPriorityFunction.java @@ -217,7 +217,7 @@ public class AnnotationReadingPriorityFunction implements PriorityFunction { if (hasRegion != null && (Boolean)hasRegion.invoke(param, (Object[])null)) { Method getRegion = methodMap.get("getRegion").get(rpcArgClass); regionSpecifier = (RegionSpecifier)getRegion.invoke(param, (Object[])null); - Region region = rpcServices.getRegion(regionSpecifier); + HRegion region = rpcServices.getRegion(regionSpecifier); if (region.getRegionInfo().isSystemTable()) { if (LOG.isTraceEnabled()) { LOG.trace("High priority because region=" + diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java index e193dcb..3e7f5e4 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactSplit.java @@ -197,10 +197,10 @@ public class CompactSplit implements PropagatingConfigurationObserver { return queueLists.toString(); } - public synchronized boolean requestSplit(final Region r) { + public synchronized boolean requestSplit(final HRegion r) { // don't split regions that are blocking - if (shouldSplitRegion() && ((HRegion)r).getCompactPriority() >= PRIORITY_USER) { - byte[] midKey = ((HRegion)r).checkSplit(); + if (shouldSplitRegion() && r.getCompactPriority() >= PRIORITY_USER) { + byte[] midKey = r.checkSplit(); if (midKey != null) { requestSplit(r, midKey); return true; @@ -209,19 +209,19 @@ public class CompactSplit implements PropagatingConfigurationObserver { return false; } - public synchronized void requestSplit(final Region r, byte[] midKey) { + public synchronized void requestSplit(final HRegion r, byte[] midKey) { requestSplit(r, midKey, null); } /* * The User parameter allows the split thread to assume the correct user identity */ - public synchronized void requestSplit(final Region r, byte[] midKey, User user) { + public synchronized void requestSplit(final HRegion r, byte[] midKey, User user) { if (midKey == null) { LOG.debug("Region " + r.getRegionInfo().getRegionNameAsString() + " not splittable because midkey=null"); - if (((HRegion)r).shouldForceSplit()) { - ((HRegion)r).clearSplit(); + if (r.shouldForceSplit()) { + r.clearSplit(); } return; } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactedHFilesDischarger.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactedHFilesDischarger.java index 72f80e4..749bc06 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactedHFilesDischarger.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/CompactedHFilesDischarger.java @@ -86,7 +86,7 @@ public class CompactedHFilesDischarger extends ScheduledChore { // Noop if rss is null. This will never happen in a normal condition except for cases // when the test case is not spinning up a cluster if (regionServerServices == null) return; - List onlineRegions = regionServerServices.getRegions(); + List onlineRegions = regionServerServices.getRegions(); if (onlineRegions == null) return; for (Region region : onlineRegions) { if (LOG.isTraceEnabled()) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequestListener.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequestListener.java index b7b4b2c..4c229b9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequestListener.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/FlushRequestListener.java @@ -28,9 +28,9 @@ public interface FlushRequestListener { /** * Callback which will get called when a flush request is made for a region. - * - * @param type The type of flush. (ie. Whether a normal flush or flush because of global heap preassure) + * @param type The type of flush. (ie. Whether a normal flush or flush because of global heap + * pressure) * @param region The region for which flush is requested */ - void flushRequested(FlushType type, Region region); + void flushRequested(FlushType type, HRegion region); } 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 5e1fc6d..239833c 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 @@ -33,7 +33,7 @@ public interface FlushRequester { * @param forceFlushAllStores whether we want to flush all stores. e.g., when request from log * rolling. */ - void requestFlush(Region region, boolean forceFlushAllStores); + void requestFlush(HRegion region, boolean forceFlushAllStores); /** * Tell the listener the cache needs to be flushed after a delay @@ -43,7 +43,7 @@ public interface FlushRequester { * @param forceFlushAllStores whether we want to flush all stores. e.g., when request from log * rolling. */ - void requestDelayedFlush(Region region, long delay, boolean forceFlushAllStores); + void 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 9552f43..6723f1b 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 @@ -103,6 +103,7 @@ import org.apache.hadoop.hbase.TagUtil; import org.apache.hadoop.hbase.UnknownScannerException; import org.apache.hadoop.hbase.client.Append; import org.apache.hadoop.hbase.client.ColumnFamilyDescriptor; +import org.apache.hadoop.hbase.client.CompactionState; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Durability; import org.apache.hadoop.hbase.client.Get; @@ -183,7 +184,6 @@ import org.apache.hadoop.hbase.shaded.com.google.common.io.Closeables; import org.apache.hadoop.hbase.shaded.com.google.protobuf.TextFormat; import org.apache.hadoop.hbase.shaded.com.google.protobuf.UnsafeByteOperations; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; -import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceCall; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionLoad; @@ -783,7 +783,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi this.metricsRegionWrapper = new MetricsRegionWrapperImpl(this); this.metricsRegion = new MetricsRegion(this.metricsRegionWrapper); - Map recoveringRegions = rsServices.getRecoveringRegions(); + Map recoveringRegions = rsServices.getRecoveringRegions(); String encodedName = getRegionInfo().getEncodedName(); if (recoveringRegions != null && recoveringRegions.containsKey(encodedName)) { this.recovering = true; @@ -1122,7 +1122,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi this.updatesLock.writeLock().unlock(); } - @Override + /** @return the block distribution for all Stores managed by this region */ public HDFSBlocksDistribution getHDFSBlocksDistribution() { HDFSBlocksDistribution hdfsBlocksDistribution = new HDFSBlocksDistribution(); stores.values().stream().filter(s -> s.getStorefiles() != null) @@ -1239,7 +1239,10 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return readRequestsCount.sum(); } - @Override + /** + * Update the read request count for this region + * @param i increment + */ public void updateReadRequestsCount(long i) { readRequestsCount.add(i); } @@ -1254,7 +1257,10 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return writeRequestsCount.sum(); } - @Override + /** + * Update the write request count for this region + * @param i increment + */ public void updateWriteRequestsCount(long i) { writeRequestsCount.add(i); } @@ -1264,7 +1270,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return memstoreDataSize.get(); } - @Override + /** @return store services for this region, to access services required by store level needs */ public RegionServicesForStores getRegionServicesForStores() { return regionServicesForStores; } @@ -1294,7 +1300,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return checkAndMutateChecksFailed.sum(); } - @Override + /** @return the MetricsRegion for this region */ public MetricsRegion getMetrics() { return metricsRegion; } @@ -1420,7 +1426,9 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return mvcc; } - @Override + /** @return the max sequence id of flushed data on this region; no edit in memory will have + * a sequence id that is less that what is returned here. + */ public long getMaxFlushedSeqId() { return maxFlushedSeqId; } @@ -1434,12 +1442,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return mvcc.getReadPoint(); } - @Override - public long getReadpoint(IsolationLevel isolationLevel) { - return getReadPoint(isolationLevel); - } - - @Override + /** @return true if loading column families on demand by default */ public boolean isLoadingCfsOnDemandDefault() { return this.isLoadingCfsOnDemandDefault; } @@ -1720,7 +1723,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return stores.values().stream().mapToLong(s -> s.getMemStoreSize().getHeapSize()).sum(); } - @Override + /** Wait for all current flushes and compactions of the region to complete */ public void waitForFlushesAndCompactions() { synchronized (writestate) { if (this.writestate.readOnly) { @@ -1749,7 +1752,7 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } } - @Override + /** Wait for all current flushes of the region to complete **/ public void waitForFlushes() { synchronized (writestate) { if (this.writestate.readOnly) { @@ -1867,7 +1870,11 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return this.fs; } - @Override + /** + * @return The earliest time a store in the region was flushed. All + * other stores in the region would have been flushed either at, or + * after this time. + */ public long getEarliestFlushTimeForAllStores() { return Collections.min(lastStoreFlushTimeMap.values()); } @@ -1942,7 +1949,19 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi stores.values().forEach(HStore::triggerMajorCompaction); } - @Override + /** + * Synchronously compact all stores in the region. + *

This operation could block for a long time, so don't call it from a + * time-sensitive thread. + *

Note that no locks are taken to prevent possible conflicts between + * compaction and splitting activities. The regionserver does not normally compact + * and split in parallel. However by calling this method you may introduce + * unexpected and unhandled concurrency. Don't do this unless you know what + * you are doing. + * + * @param majorCompaction True to force a major compaction regardless of thresholds + * @throws IOException + */ public void compact(boolean majorCompaction) throws IOException { if (majorCompaction) { triggerMajorCompaction(); @@ -2158,11 +2177,50 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } } - @Override + /** + * Flush the cache. + * + *

When this method is called the cache will be flushed unless: + *

    + *
  1. the cache is empty
  2. + *
  3. the region is closed.
  4. + *
  5. a flush is already in progress
  6. + *
  7. writes are disabled
  8. + *
+ * + *

This method may block for some time, so it should not be called from a + * time-sensitive thread. + * @param force whether we want to force a flush of all stores + * @return FlushResult indicating whether the flush was successful or not and if + * the region needs compacting + * + * @throws IOException general io exceptions + * because a snapshot was not properly persisted. + */ public FlushResult flush(boolean force) throws IOException { return flushcache(force, false); } + public static interface FlushResult { + enum Result { + FLUSHED_NO_COMPACTION_NEEDED, + FLUSHED_COMPACTION_NEEDED, + // Special case where a flush didn't run because there's nothing in the memstores. Used when + // bulk loading to know when we can still load even if a flush didn't happen. + CANNOT_FLUSH_MEMSTORE_EMPTY, + CANNOT_FLUSH + } + + /** @return the detailed result code */ + Result getResult(); + + /** @return true if the memstores were flushed, else false */ + boolean isFlushSucceeded(); + + /** @return True if the flush requested a compaction, else false */ + boolean isCompactionNeeded(); + } + /** * Flush the cache. * @@ -2806,7 +2864,6 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return new RegionScannerImpl(scan, additionalScanners, this, nonceGroup, nonce); } - @Override public void prepareDelete(Delete delete) throws IOException { // Check to see if this is a deleteRow insert if(delete.getFamilyCellMap().isEmpty()){ @@ -2855,7 +2912,14 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi doBatchMutate(delete); } - @Override + /** + * Set up correct timestamps in the Cells in Delete object. + *

Caller should have the row and region locks. + * @param mutation + * @param familyCellMap + * @param now + * @throws IOException + */ public void prepareDeleteTimestamps(Mutation mutation, Map> familyMap, byte[] byteNow) throws IOException { for (Map.Entry> e : familyMap.entrySet()) { @@ -3058,7 +3122,14 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return batchMutate(mutations, HConstants.NO_NONCE, HConstants.NO_NONCE); } - @Override + /** + * Replay a batch of mutations. + * @param mutations mutations to replay. + * @param replaySeqId + * @return an array of OperationStatus which internally contains the + * OperationStatusCode and the exceptionMessage if any. + * @throws IOException + */ public OperationStatus[] batchReplay(MutationReplay[] mutations, long replaySeqId) throws IOException { if (!RegionReplicaUtil.isDefaultReplica(getRegionInfo()) @@ -3842,7 +3913,12 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } } - @Override + /** + * Replace any cell timestamps set to {@link org.apache.hadoop.hbase.HConstants#LATEST_TIMESTAMP} + * provided current timestamp. + * @param cellItr + * @param now + */ public void updateCellTimestamps(final Iterable> cellItr, final byte[] now) throws IOException { for (List cells: cellItr) { @@ -3992,14 +4068,23 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi store.add(cell, memstoreSize); } - @Override + /** + * Check the collection of families for validity. + * @param families + * @throws NoSuchColumnFamilyException + */ public void checkFamilies(Collection families) throws NoSuchColumnFamilyException { for (byte[] family : families) { checkFamily(family); } } - @Override + /** + * Check the collection of families for valid timestamps + * @param familyMap + * @param now current timestamp + * @throws FailedSanityCheckException + */ public void checkTimestamps(final Map> familyMap, long now) throws FailedSanityCheckException { if (timestampSlop == HConstants.LATEST_TIMESTAMP) { @@ -5558,13 +5643,34 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return multipleFamilies; } - @Override + /** + * Attempts to atomically load a group of hfiles. This is critical for loading + * rows with multiple column families atomically. + * + * @param familyPaths List of Pair<byte[] column family, String hfilePath> + * @param bulkLoadListener Internal hooks enabling massaging/preparation of a + * file about to be bulk loaded + * @param assignSeqId + * @return Map from family to List of store file paths if successful, null if failed recoverably + * @throws IOException if failed unrecoverably. + */ public Map> bulkLoadHFiles(Collection> familyPaths, boolean assignSeqId, BulkLoadListener bulkLoadListener) throws IOException { return bulkLoadHFiles(familyPaths, assignSeqId, bulkLoadListener, false); } - @Override + /** + * Attempts to atomically load a group of hfiles. This is critical for loading + * rows with multiple column families atomically. + * + * @param familyPaths List of Pair<byte[] column family, String hfilePath> + * @param assignSeqId + * @param bulkLoadListener Internal hooks enabling massaging/preparation of a + * file about to be bulk loaded + * @param copyFile always copy hfiles if true + * @return Map from family to List of store file paths if successful, null if failed recoverably + * @throws IOException if failed unrecoverably. + */ public Map> bulkLoadHFiles(Collection> familyPaths, boolean assignSeqId, BulkLoadListener bulkLoadListener, boolean copyFile) throws IOException { long seqId = -1; @@ -5756,6 +5862,39 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return isSuccessful ? storeFiles : null; } + /** + * Listener class to enable callers of + * bulkLoadHFile() to perform any necessary + * pre/post processing of a given bulkload call + */ + public static interface BulkLoadListener { + /** + * Called before an HFile is actually loaded + * @param family family being loaded to + * @param srcPath path of HFile + * @return final path to be used for actual loading + * @throws IOException + */ + String prepareBulkLoad(byte[] family, String srcPath, boolean copyFile) + throws IOException; + + /** + * Called after a successful HFile load + * @param family family being loaded to + * @param srcPath path of HFile + * @throws IOException + */ + void doneBulkLoad(byte[] family, String srcPath) throws IOException; + + /** + * Called after a failed HFile load + * @param family family being loaded to + * @param srcPath path of HFile + * @throws IOException + */ + void failedBulkLoad(byte[] family, String srcPath) throws IOException; + } + @Override public boolean equals(Object o) { return o instanceof HRegion && Bytes.equals(getRegionInfo().getRegionName(), @@ -6677,11 +6816,6 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return r.openHRegion(reporter); } - public static Region openHRegion(final Region other, final CancelableProgressable reporter) - throws IOException { - return openHRegion((HRegion)other, reporter); - } - /** * Open HRegion. * Calls initialize and sets sequenceId. @@ -6874,7 +7008,15 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return get(get, withCoprocessor, HConstants.NO_NONCE, HConstants.NO_NONCE); } - @Override + /** + * Do a get for duplicate non-idempotent operation. + * @param get query parameters. + * @param withCoprocessor + * @param nonceGroup Nonce group. + * @param nonce Nonce. + * @return list of cells resulting from the operation + * @throws IOException + */ public List get(Get get, boolean withCoprocessor, long nonceGroup, long nonce) throws IOException { List results = new ArrayList<>(); @@ -7166,22 +7308,21 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } } + @Override public Result append(Append append) throws IOException { return append(append, HConstants.NO_NONCE, HConstants.NO_NONCE); } - @Override public Result append(Append mutation, long nonceGroup, long nonce) throws IOException { return doDelta(Operation.APPEND, mutation, nonceGroup, nonce, mutation.isReturnResults()); } + @Override public Result increment(Increment increment) throws IOException { return increment(increment, HConstants.NO_NONCE, HConstants.NO_NONCE); } - @Override - public Result increment(Increment mutation, long nonceGroup, long nonce) - throws IOException { + public Result increment(Increment mutation, long nonceGroup, long nonce) throws IOException { return doDelta(Operation.INCREMENT, mutation, nonceGroup, nonce, mutation.isReturnResults()); } @@ -7573,7 +7714,21 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return DEEP_OVERHEAD + stores.values().stream().mapToLong(HStore::heapSize).sum(); } - @Override + /** + * Registers a new protocol buffer {@link Service} subclass as a coprocessor endpoint to + * be available for handling Region#execService(com.google.protobuf.RpcController, + * org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall) calls. + * + *

+ * Only a single instance may be registered per region for a given {@link Service} subclass (the + * instances are keyed on {@link com.google.protobuf.Descriptors.ServiceDescriptor#getFullName()}. + * After the first registration, subsequent calls with the same service name will fail with + * a return value of {@code false}. + *

+ * @param instance the {@code Service} subclass instance to expose as a coprocessor endpoint + * @return {@code true} if the registration was successful, {@code false} + * otherwise + */ public boolean registerService(com.google.protobuf.Service instance) { /* * No stacking of instances is allowed for a single service name @@ -7596,7 +7751,20 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi return true; } - @Override + /** + * Executes a single protocol buffer coprocessor endpoint {@link Service} method using + * the registered protocol handlers. {@link Service} implementations must be registered via the + * {@link Region#registerService(com.google.protobuf.Service)} + * method before they are available. + * + * @param controller an {@code RpcContoller} implementation to pass to the invoked service + * @param call a {@code CoprocessorServiceCall} instance identifying the service, method, + * and parameters for the method invocation + * @return a protocol buffer {@code Message} instance containing the method's result + * @throws IOException if no registered service handler is found or an error + * occurs during the invocation + * @see #registerService(com.google.protobuf.Service) + */ public com.google.protobuf.Message execService(com.google.protobuf.RpcController controller, CoprocessorServiceCall call) throws IOException { @@ -7740,7 +7908,6 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi this.coprocessorHost = coprocessorHost; } - @Override public void startRegionOperation() throws IOException { startRegionOperation(Operation.ANY); } @@ -7801,7 +7968,6 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } } - @Override public void closeRegionOperation() throws IOException { closeRegionOperation(Operation.ANY); } @@ -7970,18 +8136,25 @@ public class HRegion implements HeapSize, PropagatingConfigurationObserver, Regi } }; - @Override + /** @return the latest sequence number that was read from storage when this region was opened */ public long getOpenSeqNum() { return this.openSeqNum; } - @Override + /** + * @return map of column family names to max sequence id that was read from storage when this + * region was opened + */ public Map getMaxStoreSeqId() { return this.maxSeqIdInStores; } - @Override - public long getOldestSeqIdOfStore(byte[] familyName) { + /** @return the oldest flushed sequence id for the given family; can be beyond + * {@link #getMaxFlushedSeqId()} in case where we've flushed a subset of a regions column + * families + */ + @VisibleForTesting + long getOldestSeqIdOfStore(byte[] familyName) { return wal.getEarliestMemstoreSeqNum(getRegionInfo().getEncodedNameAsBytes(), familyName); } 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 53f4445..3fdf5c5 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 @@ -290,7 +290,7 @@ public class HRegionServer extends HasThread implements * Map of regions currently being served by this region server. Key is the * encoded region name. All access should be synchronized. */ - protected final Map onlineRegions = new ConcurrentHashMap<>(); + protected final Map onlineRegions = new ConcurrentHashMap<>(); /** * Map of encoded region names to the DataNode locations they should be hosted on @@ -308,8 +308,8 @@ public class HRegionServer extends HasThread implements * Set of regions currently being in recovering state which means it can accept writes(edits from * previous failed region server) but not reads. A recovering region is also an online region. */ - protected final Map recoveringRegions = Collections - .synchronizedMap(new HashMap()); + protected final Map recoveringRegions = Collections + .synchronizedMap(new HashMap<>()); // Leases protected Leases leases; @@ -1235,7 +1235,7 @@ public class HRegionServer extends HasThread implements private boolean areAllUserRegionsOffline() { if (getNumberOfOnlineRegions() > 2) return false; boolean allUserRegionsOffline = true; - for (Map.Entry e: this.onlineRegions.entrySet()) { + for (Map.Entry e: this.onlineRegions.entrySet()) { if (!e.getValue().getRegionInfo().isMetaTable()) { allUserRegionsOffline = false; break; @@ -1249,7 +1249,7 @@ public class HRegionServer extends HasThread implements */ private long getWriteRequestCount() { long writeCount = 0; - for (Map.Entry e: this.onlineRegions.entrySet()) { + for (Map.Entry e: this.onlineRegions.entrySet()) { writeCount += e.getValue().getWriteRequestsCount(); } return writeCount; @@ -1369,7 +1369,7 @@ public class HRegionServer extends HasThread implements // improved; Additionally the load balancer will be able to take advantage of a more complete // history. MetricsRegionServerWrapper regionServerWrapper = metricsRegionServer.getRegionServerWrapper(); - Collection regions = getOnlineRegionsLocalContext(); + Collection regions = getOnlineRegionsLocalContext(); long usedMemory = -1L; long maxMemory = -1L; final MemoryUsage usage = MemorySizeUtil.safeGetHeapMemoryUsage(); @@ -1391,7 +1391,7 @@ public class HRegionServer extends HasThread implements } RegionLoad.Builder regionLoadBldr = RegionLoad.newBuilder(); RegionSpecifier.Builder regionSpecifier = RegionSpecifier.newBuilder(); - for (Region region : regions) { + for (HRegion region : regions) { if (region.getCoprocessorHost() != null) { Set regionCoprocessors = region.getCoprocessorHost().getCoprocessors(); Iterator iterator = regionCoprocessors.iterator(); @@ -1433,7 +1433,7 @@ public class HRegionServer extends HasThread implements String getOnlineRegionsAsPrintableString() { StringBuilder sb = new StringBuilder(); - for (Region r: this.onlineRegions.values()) { + for (HRegion r: this.onlineRegions.values()) { if (sb.length() > 0) sb.append(", "); sb.append(r.getRegionInfo().getEncodedName()); } @@ -1469,7 +1469,7 @@ public class HRegionServer extends HasThread implements // Ensure all user regions have been sent a close. Use this to // protect against the case where an open comes in after we start the // iterator of onlineRegions to close all user regions. - for (Map.Entry e : this.onlineRegions.entrySet()) { + for (Map.Entry e : this.onlineRegions.entrySet()) { HRegionInfo hri = e.getValue().getRegionInfo(); if (!this.regionsInTransitionInRS.containsKey(hri.getEncodedNameAsBytes()) && !closedRegions.contains(hri.getEncodedName())) { @@ -1672,7 +1672,7 @@ public class HRegionServer extends HasThread implements * * @throws IOException */ - RegionLoad createRegionLoad(final Region r, RegionLoad.Builder regionLoadBldr, + RegionLoad createRegionLoad(final HRegion r, RegionLoad.Builder regionLoadBldr, RegionSpecifier.Builder regionSpecifier) throws IOException { byte[] name = r.getRegionInfo().getRegionName(); int stores = 0; @@ -1730,7 +1730,7 @@ public class HRegionServer extends HasThread implements .setCurrentCompactedKVs(currentCompactedKVs) .setDataLocality(dataLocality) .setLastMajorCompactionTs(r.getOldestHfileTs(true)); - ((HRegion)r).setCompleteSequenceId(regionLoadBldr); + r.setCompleteSequenceId(regionLoadBldr); return regionLoadBldr.build(); } @@ -1740,7 +1740,7 @@ public class HRegionServer extends HasThread implements * @return An instance of RegionLoad. */ public RegionLoad createRegionLoad(final String encodedRegionName) throws IOException { - Region r = onlineRegions.get(encodedRegionName); + HRegion r = onlineRegions.get(encodedRegionName); return r != null ? createRegionLoad(r, null, null) : null; } @@ -1771,11 +1771,10 @@ public class HRegionServer extends HasThread implements @Override protected void chore() { - for (Region r : this.instance.onlineRegions.values()) { - if (r == null) { + for (HRegion hr : this.instance.onlineRegions.values()) { + if (hr == null) { continue; } - HRegion hr = (HRegion) r; for (HStore s : hr.stores.values()) { try { long multiplier = s.getCompactionCheckMultiplier(); @@ -1801,7 +1800,7 @@ public class HRegionServer extends HasThread implements } } } catch (IOException e) { - LOG.warn("Failed major compaction check on " + r, e); + LOG.warn("Failed major compaction check on " + hr, e); } } } @@ -1821,9 +1820,9 @@ public class HRegionServer extends HasThread implements @Override protected void chore() { final StringBuffer whyFlush = new StringBuffer(); - for (Region r : this.server.onlineRegions.values()) { + for (HRegion r : this.server.onlineRegions.values()) { if (r == null) continue; - if (((HRegion)r).shouldFlush(whyFlush)) { + if (r.shouldFlush(whyFlush)) { FlushRequester requester = server.getFlushRequester(); if (requester != null) { long randomDelay = RandomUtils.nextInt(0, RANGE_OF_DELAY) + MIN_DELAY_TIME; @@ -2157,14 +2156,14 @@ public class HRegionServer extends HasThread implements } @Override - public void postOpenDeployTasks(final Region r) throws KeeperException, IOException { + public void postOpenDeployTasks(final HRegion r) throws KeeperException, IOException { postOpenDeployTasks(new PostOpenDeployContext(r, -1)); } @Override public void postOpenDeployTasks(final PostOpenDeployContext context) throws KeeperException, IOException { - HRegion r = (HRegion) context.getRegion(); + HRegion r = context.getRegion(); long masterSystemTime = context.getMasterSystemTime(); rpcServices.checkOpen(); LOG.info("Post open deploy tasks for " + r.getRegionInfo().getRegionNameAsString()); @@ -2192,7 +2191,7 @@ public class HRegionServer extends HasThread implements + r.getRegionInfo().getRegionNameAsString()); } - triggerFlushInPrimaryRegion((HRegion)r); + triggerFlushInPrimaryRegion(r); LOG.debug("Finished post open deploy task for " + r.getRegionInfo().getRegionNameAsString()); } @@ -2664,10 +2663,10 @@ public class HRegionServer extends HasThread implements * @param abort Whether we're running an abort. */ void closeMetaTableRegions(final boolean abort) { - Region meta = null; + HRegion meta = null; this.lock.writeLock().lock(); try { - for (Map.Entry e: onlineRegions.entrySet()) { + for (Map.Entry e: onlineRegions.entrySet()) { HRegionInfo hri = e.getValue().getRegionInfo(); if (hri.isMetaRegion()) { meta = e.getValue(); @@ -2689,8 +2688,8 @@ public class HRegionServer extends HasThread implements void closeUserRegions(final boolean abort) { this.lock.writeLock().lock(); try { - for (Map.Entry e: this.onlineRegions.entrySet()) { - Region r = e.getValue(); + for (Map.Entry e: this.onlineRegions.entrySet()) { + HRegion r = e.getValue(); if (!r.getRegionInfo().isMetaTable() && r.isAvailable()) { // Don't update zk with this close transition; pass false. closeRegionIgnoreErrors(r.getRegionInfo(), abort); @@ -2720,7 +2719,7 @@ public class HRegionServer extends HasThread implements } @Override - public Map getRecoveringRegions() { + public Map getRecoveringRegions() { return this.recoveringRegions; } @@ -2751,13 +2750,13 @@ public class HRegionServer extends HasThread implements * This method will only work if HRegionServer is in the same JVM as client; * HRegion cannot be serialized to cross an rpc. */ - public Collection getOnlineRegionsLocalContext() { - Collection regions = this.onlineRegions.values(); + public Collection getOnlineRegionsLocalContext() { + Collection regions = this.onlineRegions.values(); return Collections.unmodifiableCollection(regions); } @Override - public void addRegion(Region region) { + public void addRegion(HRegion region) { this.onlineRegions.put(region.getRegionInfo().getEncodedName(), region); configurationManager.registerObserver(region); } @@ -2767,9 +2766,9 @@ public class HRegionServer extends HasThread implements * biggest. If two regions are the same size, then the last one found wins; i.e. this method * may NOT return all regions. */ - SortedMap getCopyOfOnlineRegionsSortedBySize() { + SortedMap getCopyOfOnlineRegionsSortedBySize() { // we'll sort the regions in reverse - SortedMap sortedRegions = new TreeMap<>( + SortedMap sortedRegions = new TreeMap<>( new Comparator() { @Override public int compare(Long a, Long b) { @@ -2777,7 +2776,7 @@ public class HRegionServer extends HasThread implements } }); // Copy over all regions. Regions are sorted by size with biggest first. - for (Region region : this.onlineRegions.values()) { + for (HRegion region : this.onlineRegions.values()) { sortedRegions.put(region.getMemstoreSize(), region); } return sortedRegions; @@ -2804,7 +2803,7 @@ public class HRegionServer extends HasThread implements */ protected HRegionInfo[] getMostLoadedRegions() { ArrayList regions = new ArrayList<>(); - for (Region r : onlineRegions.values()) { + for (HRegion r : onlineRegions.values()) { if (!r.isAvailable()) { continue; } @@ -3003,10 +3002,10 @@ public class HRegionServer extends HasThread implements * @return Online regions from tableName */ @Override - public List getRegions(TableName tableName) { - List tableRegions = new ArrayList<>(); + public List getRegions(TableName tableName) { + List tableRegions = new ArrayList<>(); synchronized (this.onlineRegions) { - for (Region region: this.onlineRegions.values()) { + for (HRegion region: this.onlineRegions.values()) { HRegionInfo regionInfo = region.getRegionInfo(); if(regionInfo.getTable().equals(tableName)) { tableRegions.add(region); @@ -3017,8 +3016,8 @@ public class HRegionServer extends HasThread implements } @Override - public List getRegions() { - List allRegions = new ArrayList<>(); + public List getRegions() { + List allRegions = new ArrayList<>(); synchronized (this.onlineRegions) { // Return a clone copy of the onlineRegions allRegions.addAll(onlineRegions.values()); @@ -3034,7 +3033,7 @@ public class HRegionServer extends HasThread implements public Set getOnlineTables() { Set tables = new HashSet<>(); synchronized (this.onlineRegions) { - for (Region region: this.onlineRegions.values()) { + for (HRegion region: this.onlineRegions.values()) { tables.add(region.getTableDescriptor().getTableName()); } } @@ -3051,8 +3050,8 @@ public class HRegionServer extends HasThread implements "skipping."); LOG.debug("Exception details for failure to fetch wal coprocessor information.", exception); } - Collection regions = getOnlineRegionsLocalContext(); - for (Region region: regions) { + Collection regions = getOnlineRegionsLocalContext(); + for (HRegion region: regions) { coprocessors.addAll(region.getCoprocessorHost().getCoprocessors()); try { coprocessors.addAll(getWAL(region.getRegionInfo()).getCoprocessorHost().getCoprocessors()); @@ -3103,7 +3102,7 @@ public class HRegionServer extends HasThread implements protected boolean closeRegion(String encodedName, final boolean abort, final ServerName sn) throws NotServingRegionException { //Check for permissions to close. - Region actualRegion = this.getRegion(encodedName); + HRegion actualRegion = this.getRegion(encodedName); // Can be null if we're calling close on a region that's not online if ((actualRegion != null) && (actualRegion.getCoprocessorHost() != null)) { try { @@ -3170,12 +3169,12 @@ public class HRegionServer extends HasThread implements protected boolean closeAndOfflineRegionForSplitOrMerge( final List regionEncodedName) throws IOException { for (int i = 0; i < regionEncodedName.size(); ++i) { - Region regionToClose = this.getRegion(regionEncodedName.get(i)); + HRegion regionToClose = this.getRegion(regionEncodedName.get(i)); if (regionToClose != null) { Map> hstoreFiles = null; Exception exceptionToThrow = null; try{ - hstoreFiles = ((HRegion)regionToClose).close(false); + hstoreFiles = regionToClose.close(false); } catch (Exception e) { exceptionToThrow = e; } @@ -3222,7 +3221,7 @@ public class HRegionServer extends HasThread implements * @return HRegion for the passed binary regionName or null if * named region is not member of the online regions. */ - public Region getOnlineRegion(final byte[] regionName) { + public HRegion getOnlineRegion(final byte[] regionName) { String encodedRegionName = HRegionInfo.encodeRegionName(regionName); return this.onlineRegions.get(encodedRegionName); } @@ -3232,14 +3231,14 @@ public class HRegionServer extends HasThread implements } @Override - public Region getRegion(final String encodedRegionName) { + public HRegion getRegion(final String encodedRegionName) { return this.onlineRegions.get(encodedRegionName); } @Override - public boolean removeRegion(final Region r, ServerName destination) { - Region toReturn = this.onlineRegions.remove(r.getRegionInfo().getEncodedName()); + public boolean removeRegion(final HRegion r, ServerName destination) { + HRegion toReturn = this.onlineRegions.remove(r.getRegionInfo().getEncodedName()); if (destination != null) { long closeSeqNum = r.getMaxFlushedSeqId(); if (closeSeqNum == HConstants.NO_SEQNUM) { @@ -3261,20 +3260,20 @@ public class HRegionServer extends HasThread implements * @return {@link HRegion} for regionName * @throws NotServingRegionException */ - protected Region getRegion(final byte[] regionName) + protected HRegion getRegion(final byte[] regionName) throws NotServingRegionException { String encodedRegionName = HRegionInfo.encodeRegionName(regionName); return getRegionByEncodedName(regionName, encodedRegionName); } - public Region getRegionByEncodedName(String encodedRegionName) + public HRegion getRegionByEncodedName(String encodedRegionName) throws NotServingRegionException { return getRegionByEncodedName(null, encodedRegionName); } - protected Region getRegionByEncodedName(byte[] regionName, String encodedRegionName) + protected HRegion getRegionByEncodedName(byte[] regionName, String encodedRegionName) throws NotServingRegionException { - Region region = this.onlineRegions.get(encodedRegionName); + HRegion region = this.onlineRegions.get(encodedRegionName); if (region == null) { MovedRegionInfo moveInfo = getMovedRegion(encodedRegionName); if (moveInfo != null) { @@ -3530,7 +3529,7 @@ public class HRegionServer extends HasThread implements * @throws KeeperException * @throws IOException */ - private void updateRecoveringRegionLastFlushedSequenceId(Region r) throws KeeperException, + private void updateRecoveringRegionLastFlushedSequenceId(HRegion r) throws KeeperException, IOException { if (!r.isRecovering()) { // return immdiately for non-recovering regions @@ -3688,7 +3687,7 @@ public class HRegionServer extends HasThread implements @Override public double getCompactionPressure() { double max = 0; - for (Region region : onlineRegions.values()) { + for (HRegion region : onlineRegions.values()) { for (Store store : region.getStores()) { double normCount = store.getCompactionPressure(); if (normCount > max) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HeapMemoryManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HeapMemoryManager.java index 0ee03eb..bd896a9 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HeapMemoryManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HeapMemoryManager.java @@ -403,7 +403,7 @@ public class HeapMemoryManager { } @Override - public void flushRequested(FlushType type, Region region) { + public void flushRequested(FlushType type, HRegion region) { switch (type) { case ABOVE_ONHEAP_HIGHER_MARK: blockedFlushCount.incrementAndGet(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ImmutableOnlineRegions.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ImmutableOnlineRegions.java index 3b84665..ffd1fa7 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ImmutableOnlineRegions.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/ImmutableOnlineRegions.java @@ -50,11 +50,11 @@ public interface ImmutableOnlineRegions { * @return List of Region * @throws java.io.IOException */ - List getRegions(TableName tableName) throws IOException; + List getRegions(TableName tableName) throws IOException; /** * Get all online regions in this RS. * @return List of online Region */ - List getRegions(); + List getRegions(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java index 82a5b32..f685f61 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/IncreasingToUpperBoundRegionSplitPolicy.java @@ -110,8 +110,8 @@ public class IncreasingToUpperBoundRegionSplitPolicy extends ConstantSizeRegionS TableName tablename = region.getTableDescriptor().getTableName(); int tableRegionsCount = 0; try { - List hri = rss.getRegions(tablename); - tableRegionsCount = hri == null || hri.isEmpty() ? 0 : hri.size(); + List regions = rss.getRegions(tablename); + tableRegionsCount = regions == null || regions.isEmpty() ? 0 : regions.size(); } catch (IOException e) { LOG.debug("Failed getOnlineRegions " + tablename, e); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/LogRoller.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/LogRoller.java index 30f9a51..d344e18 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/LogRoller.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/LogRoller.java @@ -210,7 +210,7 @@ public class LogRoller extends HasThread implements Closeable { requester = this.services.getFlushRequester(); if (requester != null) { // force flushing all stores to clean old logs - requester.requestFlush(r, true); + requester.requestFlush((HRegion) r, true); scheduled = true; } } 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 8fa686c..8851724 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 @@ -46,7 +46,7 @@ import org.apache.hadoop.hbase.DroppedSnapshotException; import org.apache.hadoop.hbase.HConstants; import org.apache.yetus.audience.InterfaceAudience; import org.apache.hadoop.hbase.client.RegionReplicaUtil; -import org.apache.hadoop.hbase.regionserver.Region.FlushResult; +import org.apache.hadoop.hbase.regionserver.HRegion.FlushResult; import org.apache.hadoop.hbase.shaded.com.google.common.base.Preconditions; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; @@ -76,7 +76,7 @@ class MemStoreFlusher implements FlushRequester { // These two data members go together. Any entry in the one must have // a corresponding entry in the other. private final BlockingQueue flushQueue = new DelayQueue<>(); - private final Map regionsInQueue = new HashMap<>(); + private final Map regionsInQueue = new HashMap<>(); private AtomicBoolean wakeupPending = new AtomicBoolean(); private final long threadWakeFrequency; @@ -126,8 +126,8 @@ class MemStoreFlusher implements FlushRequester { * @return true if successful */ private boolean flushOneForGlobalPressure() { - SortedMap regionsBySize = server.getCopyOfOnlineRegionsSortedBySize(); - Set excludedRegions = new HashSet<>(); + SortedMap regionsBySize = server.getCopyOfOnlineRegionsSortedBySize(); + Set excludedRegions = new HashSet<>(); double secondaryMultiplier = ServerRegionReplicaUtil.getRegionReplicaStoreFileRefreshMultiplier(conf); @@ -136,12 +136,12 @@ class MemStoreFlusher implements FlushRequester { while (!flushedOne) { // Find the biggest region that doesn't have too many storefiles // (might be null!) - Region bestFlushableRegion = getBiggestMemstoreRegion(regionsBySize, excludedRegions, true); + HRegion bestFlushableRegion = getBiggestMemstoreRegion(regionsBySize, excludedRegions, true); // Find the biggest region, total, even if it might have too many flushes. - Region bestAnyRegion = getBiggestMemstoreRegion( + HRegion bestAnyRegion = getBiggestMemstoreRegion( regionsBySize, excludedRegions, false); // Find the biggest region that is a secondary region - Region bestRegionReplica = getBiggestMemstoreOfRegionReplica(regionsBySize, + HRegion bestRegionReplica = getBiggestMemstoreOfRegionReplica(regionsBySize, excludedRegions); if (bestAnyRegion == null && bestRegionReplica == null) { @@ -149,7 +149,7 @@ class MemStoreFlusher implements FlushRequester { return false; } - Region regionToFlush; + HRegion regionToFlush; if (bestFlushableRegion != null && bestAnyRegion.getMemstoreSize() > 2 * bestFlushableRegion.getMemstoreSize()) { // Even if it's not supposed to be flushed, pick a region if it's more than twice @@ -283,18 +283,16 @@ class MemStoreFlusher implements FlushRequester { } } - private Region getBiggestMemstoreRegion( - SortedMap regionsBySize, - Set excludedRegions, - boolean checkStoreFileCount) { + private HRegion getBiggestMemstoreRegion(SortedMap regionsBySize, + Set excludedRegions, boolean checkStoreFileCount) { synchronized (regionsInQueue) { - for (Region region : regionsBySize.values()) { + for (HRegion region : regionsBySize.values()) { if (excludedRegions.contains(region)) { continue; } - if (((HRegion)region).writestate.flushing || - !((HRegion)region).writestate.writesEnabled) { + if (region.writestate.flushing || + !region.writestate.writesEnabled) { continue; } @@ -307,25 +305,23 @@ class MemStoreFlusher implements FlushRequester { return null; } - private Region getBiggestMemstoreOfRegionReplica(SortedMap regionsBySize, - Set excludedRegions) { + private HRegion getBiggestMemstoreOfRegionReplica(SortedMap regionsBySize, + Set excludedRegions) { synchronized (regionsInQueue) { - for (Region region : regionsBySize.values()) { + for (HRegion region : regionsBySize.values()) { if (excludedRegions.contains(region)) { continue; } - if (RegionReplicaUtil.isDefaultReplica(region.getRegionInfo())) { continue; } - return region; } } return null; } - private boolean refreshStoreFilesAndReclaimMemory(Region region) { + private boolean refreshStoreFilesAndReclaimMemory(HRegion region) { try { return region.refreshStoreFiles(); } catch (IOException e) { @@ -349,8 +345,8 @@ class MemStoreFlusher implements FlushRequester { } @Override - public void requestFlush(Region r, boolean forceFlushAllStores) { - ((HRegion)r).incrementFlushesQueuedCount(); + public void requestFlush(HRegion r, boolean forceFlushAllStores) { + r.incrementFlushesQueuedCount(); synchronized (regionsInQueue) { if (!regionsInQueue.containsKey(r)) { // This entry has no delay so it will be added at the top of the flush @@ -363,8 +359,8 @@ class MemStoreFlusher implements FlushRequester { } @Override - public void requestDelayedFlush(Region r, long delay, boolean forceFlushAllStores) { - ((HRegion)r).incrementFlushesQueuedCount(); + public void requestDelayedFlush(HRegion r, long delay, boolean forceFlushAllStores) { + r.incrementFlushesQueuedCount(); synchronized (regionsInQueue) { if (!regionsInQueue.containsKey(r)) { // This entry has some delay @@ -430,7 +426,7 @@ class MemStoreFlusher implements FlushRequester { * not flushed. */ private boolean flushRegion(final FlushRegionEntry fqe) { - Region region = fqe.region; + HRegion region = fqe.region; if (!region.getRegionInfo().isMetaRegion() && isTooManyStoreFiles(region)) { if (fqe.isMaximumWait(this.blockingWaitTime)) { @@ -446,7 +442,7 @@ class MemStoreFlusher implements FlushRequester { "store files; delaying flush up to " + this.blockingWaitTime + "ms"); if (!this.server.compactSplitThread.requestSplit(region)) { try { - this.server.compactSplitThread.requestSystemCompaction((HRegion) region, + this.server.compactSplitThread.requestSystemCompaction(region, Thread.currentThread().getName()); } catch (IOException e) { e = e instanceof RemoteException ? @@ -479,7 +475,7 @@ class MemStoreFlusher implements FlushRequester { * false, there will be accompanying log messages explaining why the region was * not flushed. */ - private boolean flushRegion(final Region region, final boolean emergencyFlush, + private boolean flushRegion(final HRegion region, final boolean emergencyFlush, boolean forceFlushAllStores) { synchronized (this.regionsInQueue) { FlushRegionEntry fqe = this.regionsInQueue.remove(region); @@ -497,11 +493,11 @@ class MemStoreFlusher implements FlushRequester { FlushResult flushResult = region.flush(forceFlushAllStores); boolean shouldCompact = flushResult.isCompactionNeeded(); // We just want to check the size - boolean shouldSplit = ((HRegion)region).checkSplit() != null; + boolean shouldSplit = region.checkSplit() != null; if (shouldSplit) { this.server.compactSplitThread.requestSplit(region); } else if (shouldCompact) { - server.compactSplitThread.requestSystemCompaction((HRegion) region, + server.compactSplitThread.requestSystemCompaction(region, Thread.currentThread().getName()); } } catch (DroppedSnapshotException ex) { @@ -529,7 +525,7 @@ class MemStoreFlusher implements FlushRequester { return true; } - private void notifyFlushRequest(Region region, boolean emergencyFlush) { + private void notifyFlushRequest(HRegion region, boolean emergencyFlush) { FlushType type = null; if (emergencyFlush) { type = isAboveHighWaterMark(); @@ -548,7 +544,7 @@ class MemStoreFlusher implements FlushRequester { } } - private boolean isTooManyStoreFiles(Region region) { + private boolean isTooManyStoreFiles(HRegion region) { // When compaction is disabled, the region is flushable if (!region.getTableDescriptor().isCompactionEnabled()) { @@ -728,7 +724,7 @@ class MemStoreFlusher implements FlushRequester { * a while. */ static class FlushRegionEntry implements FlushQueueEntry { - private final Region region; + private final HRegion region; private final long createTime; private long whenToExpire; @@ -736,7 +732,7 @@ class MemStoreFlusher implements FlushRequester { private boolean forceFlushAllStores; - FlushRegionEntry(final Region r, boolean forceFlushAllStores) { + FlushRegionEntry(final HRegion r, boolean forceFlushAllStores) { this.region = r; this.createTime = EnvironmentEdgeManager.currentTime(); this.whenToExpire = this.createTime; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServerWrapperImpl.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServerWrapperImpl.java index a99dcd6..076604a 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServerWrapperImpl.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsRegionServerWrapperImpl.java @@ -214,7 +214,7 @@ class MetricsRegionServerWrapperImpl @Override public long getNumOnlineRegions() { - Collection onlineRegionsLocalContext = regionServer.getOnlineRegionsLocalContext(); + Collection onlineRegionsLocalContext = regionServer.getOnlineRegionsLocalContext(); if (onlineRegionsLocalContext == null) { return 0; } @@ -754,7 +754,7 @@ class MetricsRegionServerWrapperImpl long tempMobScanCellsSize = 0; long tempBlockedRequestsCount = 0; int regionCount = 0; - for (Region r : regionServer.getOnlineRegionsLocalContext()) { + for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { tempNumMutationsWithoutWAL += r.getNumMutationsWithoutWAL(); tempDataInMemoryWithoutWAL += r.getDataInMemoryWithoutWAL(); tempReadRequestsCount += r.getReadRequestsCount(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java index 4eea146..89dc42d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/MetricsTableWrapperAggregateImpl.java @@ -61,7 +61,7 @@ public class MetricsTableWrapperAggregateImpl implements MetricsTableWrapperAggr public void run() { Map localMetricsTableMap = new HashMap<>(); - for (Region r : regionServer.getOnlineRegionsLocalContext()) { + for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { TableName tbl= r.getTableDescriptor().getTableName(); MetricsTableValues metricsTable = localMetricsTableMap.get(tbl); if (metricsTable == null) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/OnlineRegions.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/OnlineRegions.java index d389bdf..c9f1c47 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/OnlineRegions.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/OnlineRegions.java @@ -32,7 +32,7 @@ public interface OnlineRegions extends ImmutableOnlineRegions { * Add to online regions. * @param r */ - void addRegion(final Region r); + void addRegion(final HRegion r); /** * This method removes Region corresponding to hri from the Map of onlineRegions. @@ -41,5 +41,5 @@ public interface OnlineRegions extends ImmutableOnlineRegions { * @param destination Destination, if any, null otherwise. * @return True if we removed a region from online list. */ - boolean removeRegion(final Region r, ServerName destination); + boolean removeRegion(final HRegion r, ServerName destination); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java index 8690b70..f66f832 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSDumpServlet.java @@ -106,8 +106,7 @@ public class RSDumpServlet extends StateDumpServlet { public static void dumpRowLock(HRegionServer hrs, PrintWriter out) { StringBuilder sb = new StringBuilder(); - for (Region region : hrs.getRegions()) { - HRegion hRegion = (HRegion)region; + for (HRegion hRegion : hrs.getRegions()) { if (hRegion.getLockedRows().size() > 0) { for (HRegion.RowLockContext rowLockContext : hRegion.getLockedRows().values()) { sb.setLength(0); 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 e71c1eb..c716d2a 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 @@ -388,13 +388,13 @@ public class RSRpcServices implements HBaseRPCErrorHandler, private final AtomicLong nextCallSeq = new AtomicLong(0); private final String scannerName; private final RegionScanner s; - private final Region r; + private final HRegion r; private final RpcCallback closeCallBack; private final RpcCallback shippedCallback; private byte[] rowOfLastPartialResult; private boolean needCursor; - public RegionScannerHolder(String scannerName, RegionScanner s, Region r, + public RegionScannerHolder(String scannerName, RegionScanner s, HRegion r, RpcCallback closeCallBack, RpcCallback shippedCallback, boolean needCursor) { this.scannerName = scannerName; this.s = s; @@ -432,7 +432,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, RegionScanner s = rsh.s; LOG.info("Scanner " + this.scannerName + " lease expired on region " + s.getRegionInfo().getRegionNameAsString()); - Region region = null; + HRegion region = null; try { region = regionServer.getRegion(s.getRegionInfo().getRegionName()); if (region != null && region.getCoprocessorHost() != null) { @@ -547,7 +547,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * @param cellScanner if non-null, the mutation data -- the Cell content. * @throws IOException */ - private void mutateRows(final Region region, + private void mutateRows(final HRegion region, final List actions, final CellScanner cellScanner, RegionActionResult.Builder builder) throws IOException { if (!region.getRegionInfo().isMetaTable()) { @@ -600,7 +600,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * @param compareOp * @param comparator @throws IOException */ - private boolean checkAndRowMutate(final Region region, final List actions, + private boolean checkAndRowMutate(final HRegion region, final List actions, final CellScanner cellScanner, byte[] row, byte[] family, byte[] qualifier, CompareOperator op, ByteArrayComparable comparator, RegionActionResult.Builder builder, ActivePolicyEnforcement spaceQuotaEnforcement) throws IOException { @@ -656,7 +656,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * bypassed as indicated by RegionObserver, null otherwise * @throws IOException */ - private Result append(final Region region, final OperationQuota quota, + private Result append(final HRegion region, final OperationQuota quota, final MutationProto mutation, final CellScanner cellScanner, long nonceGroup, ActivePolicyEnforcement spaceQuota) throws IOException { @@ -707,7 +707,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * @return the Result * @throws IOException */ - private Result increment(final Region region, final OperationQuota quota, + private Result increment(final HRegion region, final OperationQuota quota, final MutationProto mutation, final CellScanner cells, long nonceGroup, ActivePolicyEnforcement spaceQuota) throws IOException { @@ -763,7 +763,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * @param context the current RpcCallContext * @return Return the cellScanner passed */ - private List doNonAtomicRegionMutation(final Region region, + private List doNonAtomicRegionMutation(final HRegion region, final OperationQuota quota, final RegionAction actions, final CellScanner cellScanner, final RegionActionResult.Builder builder, List cellsToReturn, long nonceGroup, final RegionScannersCloseCallBack closeCallBack, RpcCallContext context, @@ -826,7 +826,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { Get get = ProtobufUtil.toGet(action.getGet()); if (context != null) { - r = get(get, ((HRegion) region), closeCallBack, context); + r = get(get, region, closeCallBack, context); } else { r = region.get(get); } @@ -926,11 +926,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, return cellsToReturn; } - private void checkCellSizeLimit(final Region region, final Mutation m) throws IOException { - if (!(region instanceof HRegion)) { - return; - } - HRegion r = (HRegion)region; + private void checkCellSizeLimit(final HRegion r, final Mutation m) throws IOException { if (r.maxCellSize > 0) { CellScanner cells = m.cellScanner(); while (cells.advance()) { @@ -953,7 +949,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * @param region * @param mutations */ - private void doBatchOp(final RegionActionResult.Builder builder, final Region region, + private void doBatchOp(final RegionActionResult.Builder builder, final HRegion region, final OperationQuota quota, final List mutations, final CellScanner cells, ActivePolicyEnforcement spaceQuotaEnforcement) { Mutation[] mArray = new Mutation[mutations.size()]; @@ -1050,7 +1046,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * exceptionMessage if any * @throws IOException */ - private OperationStatus [] doReplayBatchOp(final Region region, + private OperationStatus [] doReplayBatchOp(final HRegion region, final List mutations, long replaySeqId) throws IOException { long before = EnvironmentEdgeManager.currentTime(); boolean batchContainsPuts = false, batchContainsDelete = false; @@ -1070,27 +1066,26 @@ public class RSRpcServices implements HBaseRPCErrorHandler, for (Cell metaCell : metaCells) { CompactionDescriptor compactionDesc = WALEdit.getCompaction(metaCell); boolean isDefaultReplica = RegionReplicaUtil.isDefaultReplica(region.getRegionInfo()); - HRegion hRegion = (HRegion)region; if (compactionDesc != null) { // replay the compaction. Remove the files from stores only if we are the primary // region replica (thus own the files) - hRegion.replayWALCompactionMarker(compactionDesc, !isDefaultReplica, isDefaultReplica, + region.replayWALCompactionMarker(compactionDesc, !isDefaultReplica, isDefaultReplica, replaySeqId); continue; } FlushDescriptor flushDesc = WALEdit.getFlushDescriptor(metaCell); if (flushDesc != null && !isDefaultReplica) { - hRegion.replayWALFlushMarker(flushDesc, replaySeqId); + region.replayWALFlushMarker(flushDesc, replaySeqId); continue; } RegionEventDescriptor regionEvent = WALEdit.getRegionEventDescriptor(metaCell); if (regionEvent != null && !isDefaultReplica) { - hRegion.replayWALRegionEventMarker(regionEvent); + region.replayWALRegionEventMarker(regionEvent); continue; } BulkLoadDescriptor bulkLoadEvent = WALEdit.getBulkLoadDescriptor(metaCell); if (bulkLoadEvent != null) { - hRegion.replayWALBulkLoadEventMarker(bulkLoadEvent); + region.replayWALBulkLoadEventMarker(bulkLoadEvent); continue; } } @@ -1335,7 +1330,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, return lastBlock; } - private RegionScannerHolder addScanner(String scannerName, RegionScanner s, Region r, + private RegionScannerHolder addScanner(String scannerName, RegionScanner s, HRegion r, boolean needCursor) throws LeaseStillHeldException { Lease lease = regionServer.leases.createLease(scannerName, this.scannerLeaseTimeoutPeriod, new ScannerListener(scannerName)); @@ -1363,7 +1358,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, * but failed to find the region */ @VisibleForTesting - public Region getRegion( + public HRegion getRegion( final RegionSpecifier regionSpecifier) throws IOException { ByteString value = regionSpecifier.getValue(); RegionSpecifierType type = regionSpecifier.getType(); @@ -1543,7 +1538,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - HRegion region = (HRegion) getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); // Quota support is enabled, the requesting user is not system/super user // and a quota policy is enforced that disables compactions. if (QuotaUtil.isQuotaEnabled(getConfiguration()) && @@ -1611,7 +1606,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - HRegion region = (HRegion) getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); LOG.info("Flushing " + region.getRegionInfo().getRegionNameAsString()); boolean shouldFlush = true; if (request.hasIfOlderThanTs()) { @@ -1652,9 +1647,9 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - Map onlineRegions = regionServer.onlineRegions; + Map onlineRegions = regionServer.onlineRegions; List list = new ArrayList<>(onlineRegions.size()); - for (Region region: onlineRegions.values()) { + for (HRegion region: onlineRegions.values()) { list.add(region.getRegionInfo()); } Collections.sort(list); @@ -1671,26 +1666,25 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); HRegionInfo info = region.getRegionInfo(); byte[] bestSplitRow = null; if (request.hasBestSplitRow() && request.getBestSplitRow()) { - HRegion r = (HRegion) region; region.startRegionOperation(Operation.SPLIT_REGION); - r.forceSplit(null); - bestSplitRow = r.checkSplit(); + region.forceSplit(null); + bestSplitRow = region.checkSplit(); // when all table data are in memstore, bestSplitRow = null // try to flush region first - if(bestSplitRow == null) { - r.flush(true); - bestSplitRow = r.checkSplit(); + if (bestSplitRow == null) { + region.flush(true); + bestSplitRow = region.checkSplit(); } - r.clearSplit(); + region.clearSplit(); } GetRegionInfoResponse.Builder builder = GetRegionInfoResponse.newBuilder(); builder.setRegionInfo(HRegionInfo.convert(info)); if (request.hasCompactionState() && request.getCompactionState()) { - builder.setCompactionState(region.getCompactionState()); + builder.setCompactionState(ProtobufUtil.createCompactionState(region.getCompactionState())); } builder.setSplittable(region.isSplittable()); builder.setMergeable(region.isMergeable()); @@ -1709,7 +1703,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, public GetRegionLoadResponse getRegionLoad(RpcController controller, GetRegionLoadRequest request) throws ServiceException { - List regions; + List regions; if (request.hasTableName()) { TableName tableName = ProtobufUtil.toTableName(request.getTableName()); regions = regionServer.getRegions(tableName); @@ -1721,7 +1715,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, RegionSpecifier.Builder regionSpecifier = RegionSpecifier.newBuilder(); try { - for (Region region : regions) { + for (HRegion region : regions) { rLoads.add(regionServer.createRegionLoad(region, regionLoadBuilder, regionSpecifier)); } } catch (IOException e) { @@ -1797,7 +1791,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, final GetStoreFileRequest request) throws ServiceException { try { checkOpen(); - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); requestCount.increment(); Set columnFamilies; if (request.getFamilyCount() == 0) { @@ -1902,7 +1896,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { String encodedName = region.getEncodedName(); byte[] encodedNameBytes = region.getEncodedNameAsBytes(); - final Region onlineRegion = regionServer.getRegion(encodedName); + final HRegion onlineRegion = regionServer.getRegion(encodedName); if (onlineRegion != null) { // The region is already online. This should not happen any more. String error = "Received OPEN for the region:" @@ -2027,7 +2021,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, checkOpen(); String encodedName = region.getEncodedName(); byte[] encodedNameBytes = region.getEncodedNameAsBytes(); - final Region onlineRegion = regionServer.getRegion(encodedName); + final HRegion onlineRegion = regionServer.getRegion(encodedName); if (onlineRegion != null) { LOG.info("Region already online. Skipping warming up " + region); @@ -2078,7 +2072,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, return ReplicateWALEntryResponse.newBuilder().build(); } ByteString regionName = entries.get(0).getKey().getEncodedRegionName(); - Region region = regionServer.getRegionByEncodedName(regionName.toStringUtf8()); + HRegion region = regionServer.getRegionByEncodedName(regionName.toStringUtf8()); RegionCoprocessorHost coprocessorHost = ServerRegionReplicaUtil.isDefaultReplica(region.getRegionInfo()) ? region.getCoprocessorHost() @@ -2156,8 +2150,8 @@ public class RSRpcServices implements HBaseRPCErrorHandler, } } - WAL getWAL(Region region) { - return ((HRegion)region).getWAL(); + WAL getWAL(HRegion region) { + return region.getWAL(); } /** @@ -2259,7 +2253,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); boolean bypass = false; boolean loaded = false; Map> map = null; @@ -2328,9 +2322,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - - Region region = getRegion(request.getRegion()); - + HRegion region = getRegion(request.getRegion()); String bulkToken = regionServer.secureBulkLoadManager.prepareBulkLoad(region, request); PrepareBulkLoadResponse.Builder builder = PrepareBulkLoadResponse.newBuilder(); builder.setBulkToken(bulkToken); @@ -2346,9 +2338,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - - Region region = getRegion(request.getRegion()); - + HRegion region = getRegion(request.getRegion()); regionServer.secureBulkLoadManager.cleanupBulkLoad(region, request); CleanupBulkLoadResponse response = CleanupBulkLoadResponse.newBuilder().build(); return response; @@ -2363,7 +2353,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, try { checkOpen(); requestCount.increment(); - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); com.google.protobuf.Message result = execServiceOnRegion(region, request.getCall()); CoprocessorServiceResponse.Builder builder = CoprocessorServiceResponse.newBuilder(); builder.setRegion(RequestConverter.buildRegionSpecifier( @@ -2378,7 +2368,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, } } - private com.google.protobuf.Message execServiceOnRegion(Region region, + private com.google.protobuf.Message execServiceOnRegion(HRegion region, final ClientProtos.CoprocessorServiceCall serviceCall) throws IOException { // ignore the passed in controller (from the serialized call) ServerRpcController execController = new ServerRpcController(); @@ -2402,7 +2392,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, requestCount.increment(); requestRowActionCount.increment(); rpcGetRequestCount.increment(); - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); GetResponse.Builder builder = GetResponse.newBuilder(); ClientProtos.Get get = request.getGet(); @@ -2417,7 +2407,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, } if (existence == null) { if (context != null) { - r = get(clientGet, ((HRegion) region), null, context); + r = get(clientGet, region, null, context); } else { // for test purpose r = region.get(clientGet); @@ -2568,7 +2558,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, for (RegionAction regionAction : request.getRegionActionList()) { this.requestRowActionCount.add(regionAction.getActionCount()); OperationQuota quota; - Region region; + HRegion region; regionActionResultBuilder.clear(); RegionSpecifier regionSpecifier = regionAction.getRegion(); try { @@ -2628,8 +2618,8 @@ public class RSRpcServices implements HBaseRPCErrorHandler, } responseBuilder.addRegionActionResult(regionActionResultBuilder.build()); quota.close(); - ClientProtos.RegionLoadStats regionLoadStats = ((HRegion)region).getLoadStatistics(); - if(regionLoadStats != null) { + ClientProtos.RegionLoadStats regionLoadStats = region.getLoadStatistics(); + if (regionLoadStats != null) { regionStats.put(regionSpecifier, regionLoadStats); } } @@ -2703,7 +2693,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, requestCount.increment(); requestRowActionCount.increment(); rpcMutateRequestCount.increment(); - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); MutateResponse.Builder builder = MutateResponse.newBuilder(); MutationProto mutation = request.getMutation(); if (!region.getRegionInfo().isMetaTable()) { @@ -2893,7 +2883,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, private RegionScannerHolder newRegionScanner(ScanRequest request, ScanResponse.Builder builder) throws IOException { - Region region = getRegion(request.getRegion()); + HRegion region = getRegion(request.getRegion()); ClientProtos.Scan protoScan = request.getScan(); boolean isLoadingCfsOnDemandSet = protoScan.hasLoadColumnFamiliesOnDemand(); Scan scan = ProtobufUtil.toScan(protoScan); @@ -2993,7 +2983,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, long maxQuotaResultSize, int maxResults, int limitOfRows, List results, ScanResponse.Builder builder, MutableObject lastBlock, RpcCallContext context) throws IOException { - Region region = rsh.r; + HRegion region = rsh.r; RegionScanner scanner = rsh.s; long maxResultSize; if (scanner.getMaxResultSize() > 0) { @@ -3227,7 +3217,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, } throw new ServiceException(e); } - Region region = rsh.r; + HRegion region = rsh.r; String scannerName = rsh.scannerName; Leases.Lease lease; try { @@ -3408,7 +3398,7 @@ public class RSRpcServices implements HBaseRPCErrorHandler, } } - private void closeScanner(Region region, RegionScanner scanner, String scannerName, + private void closeScanner(HRegion region, RegionScanner scanner, String scannerName, RpcCallContext context) throws IOException { if (region.getCoprocessorHost() != null) { if (region.getCoprocessorHost().preScannerClose(scanner)) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java index 073c25f..43fa20d 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/Region.java @@ -20,16 +20,14 @@ package org.apache.hadoop.hbase.regionserver; import java.io.IOException; import java.util.Collection; import java.util.List; -import java.util.Map; -import org.apache.hadoop.fs.Path; import org.apache.hadoop.hbase.Cell; import org.apache.hadoop.hbase.CellComparator; import org.apache.hadoop.hbase.CompareOperator; import org.apache.hadoop.hbase.HBaseInterfaceAudience; -import org.apache.hadoop.hbase.HDFSBlocksDistribution; import org.apache.hadoop.hbase.HRegionInfo; import org.apache.hadoop.hbase.client.Append; +import org.apache.hadoop.hbase.client.CompactionState; import org.apache.hadoop.hbase.client.Delete; import org.apache.hadoop.hbase.client.Get; import org.apache.hadoop.hbase.client.Increment; @@ -41,20 +39,12 @@ import org.apache.hadoop.hbase.client.RowMutations; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.client.TableDescriptor; import org.apache.hadoop.hbase.conf.ConfigurationObserver; -import org.apache.hadoop.hbase.exceptions.FailedSanityCheckException; import org.apache.hadoop.hbase.filter.ByteArrayComparable; import org.apache.hadoop.hbase.regionserver.compactions.CompactionLifeCycleTracker; import org.apache.hadoop.hbase.security.User; -import org.apache.hadoop.hbase.util.Pair; -import org.apache.hadoop.hbase.wal.WALSplitter.MutationReplay; import org.apache.yetus.audience.InterfaceAudience; import org.apache.yetus.audience.InterfaceStability; -import org.apache.hadoop.hbase.shaded.com.google.common.annotations.VisibleForTesting; -import org.apache.hadoop.hbase.shaded.com.google.protobuf.Service; -import org.apache.hadoop.hbase.shaded.protobuf.generated.AdminProtos.GetRegionInfoResponse.CompactionState; -import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.CoprocessorServiceCall; - /** * Regions store data for a certain region of a table. It stores all columns * for each row. A given table consists of one or more Regions. @@ -131,24 +121,6 @@ public interface Region extends ConfigurationObserver { */ boolean refreshStoreFiles() throws IOException; - /** @return the latest sequence number that was read from storage when this region was opened */ - long getOpenSeqNum(); - - /** @return the max sequence id of flushed data on this region; no edit in memory will have - * a sequence id that is less that what is returned here. - */ - long getMaxFlushedSeqId(); - - /** @return the oldest flushed sequence id for the given family; can be beyond - * {@link #getMaxFlushedSeqId()} in case where we've flushed a subset of a regions column - * families - * @deprecated Since version 1.2.0. Exposes too much about our internals; shutting it down. - * Do not use. - */ - @VisibleForTesting - @Deprecated - public long getOldestSeqIdOfStore(byte[] familyName); - /** * This can be used to determine the last time all files of this region were major compacted. * @param majorCompactionOnly Only consider HFile that are the result of major compaction @@ -156,44 +128,15 @@ public interface Region extends ConfigurationObserver { */ long getOldestHfileTs(boolean majorCompactionOnly) throws IOException; - /** - * @return map of column family names to max sequence id that was read from storage when this - * region was opened - */ - public Map getMaxStoreSeqId(); - - /** @return true if loading column families on demand by default */ - boolean isLoadingCfsOnDemandDefault(); - /** @return readpoint considering given IsolationLevel; pass null for default*/ long getReadPoint(IsolationLevel isolationLevel); - /** - * @return readpoint considering given IsolationLevel - * @deprecated Since 1.2.0. Use {@link #getReadPoint(IsolationLevel)} instead. - */ - @Deprecated - long getReadpoint(IsolationLevel isolationLevel); - - /** - * @return The earliest time a store in the region was flushed. All - * other stores in the region would have been flushed either at, or - * after this time. - */ - long getEarliestFlushTimeForAllStores(); - /////////////////////////////////////////////////////////////////////////// // Metrics /** @return read requests count for this region */ long getReadRequestsCount(); - /** - * Update the read request count for this region - * @param i increment - */ - void updateReadRequestsCount(long i); - /** @return filtered read requests count for this region */ long getFilteredReadRequestsCount(); @@ -201,21 +144,12 @@ public interface Region extends ConfigurationObserver { long getWriteRequestsCount(); /** - * Update the write request count for this region - * @param i increment - */ - void updateWriteRequestsCount(long i); - - /** * @return memstore size for this region, in bytes. It just accounts data size of cells added to * the memstores of this Region. Means size in bytes for key, value and tags within Cells. * It wont consider any java heap overhead for the cell objects or any other. */ long getMemstoreSize(); - /** @return store services for this region, to access services required by store level needs */ - RegionServicesForStores getRegionServicesForStores(); - /** @return the number of mutations processed bypassing the WAL */ long getNumMutationsWithoutWAL(); @@ -231,36 +165,6 @@ public interface Region extends ConfigurationObserver { /** @return the number of failed checkAndMutate guards */ long getCheckAndMutateChecksFailed(); - /** @return the MetricsRegion for this region */ - MetricsRegion getMetrics(); - - /** @return the block distribution for all Stores managed by this region */ - HDFSBlocksDistribution getHDFSBlocksDistribution(); - - /////////////////////////////////////////////////////////////////////////// - // Locking - - // Region read locks - - /** - * Operation enum is used in {@link Region#startRegionOperation} and elsewhere to provide - * context for various checks. - */ - enum Operation { - ANY, GET, PUT, DELETE, SCAN, APPEND, INCREMENT, SPLIT_REGION, MERGE_REGION, BATCH_MUTATE, - REPLAY_BATCH_MUTATE, COMPACT_REGION, REPLAY_EVENT, SNAPSHOT - } - - /** - * This method needs to be called before any public call that reads or - * modifies data. - * Acquires a read lock and checks if the region is closing or closed. - *

{@link #closeRegionOperation} MUST then always be called after - * the operation has completed, whether it succeeded or failed. - * @throws IOException - */ - void startRegionOperation() throws IOException; - /** * This method needs to be called before any public call that reads or * modifies data. @@ -273,17 +177,20 @@ public interface Region extends ConfigurationObserver { void startRegionOperation(Operation op) throws IOException; /** - * Closes the region operation lock. + * Closes the region operation lock. This needs to be called in the finally block corresponding + * to the try block of {@link #startRegionOperation(Operation)} * @throws IOException */ - void closeRegionOperation() throws IOException; + void closeRegionOperation(Operation operation) throws IOException; /** - * Closes the region operation lock. This needs to be called in the finally block corresponding - * to the try block of {@link #startRegionOperation(Operation)} - * @throws IOException + * Operation enum is used in {@link Region#startRegionOperation} and elsewhere to provide + * context for various checks. */ - void closeRegionOperation(Operation op) throws IOException; + enum Operation { + ANY, GET, PUT, DELETE, SCAN, APPEND, INCREMENT, SPLIT_REGION, MERGE_REGION, BATCH_MUTATE, + REPLAY_BATCH_MUTATE, COMPACT_REGION, REPLAY_EVENT, SNAPSHOT + } // Row write locks @@ -332,12 +239,10 @@ public interface Region extends ConfigurationObserver { /** * Perform one or more append operations on a row. * @param append - * @param nonceGroup - * @param nonce * @return result of the operation * @throws IOException */ - Result append(Append append, long nonceGroup, long nonce) throws IOException; + Result append(Append append) throws IOException; /** * Perform a batch of mutations. @@ -354,16 +259,6 @@ public interface Region extends ConfigurationObserver { throws IOException; /** - * Replay a batch of mutations. - * @param mutations mutations to replay. - * @param replaySeqId - * @return an array of OperationStatus which internally contains the - * OperationStatusCode and the exceptionMessage if any. - * @throws IOException - */ - OperationStatus[] batchReplay(MutationReplay[] mutations, long replaySeqId) throws IOException; - - /** * Atomically checks if a row/family/qualifier value matches the expected value and if it does, * it performs the mutation. If the passed value is null, the lack of column value * (ie: non-existence) is used. See checkAndRowMutate to do many checkAndPuts at a time on a @@ -424,17 +319,6 @@ public interface Region extends ConfigurationObserver { List get(Get get, boolean withCoprocessor) throws IOException; /** - * Do a get for duplicate non-idempotent operation. - * @param get query parameters. - * @param withCoprocessor - * @param nonceGroup Nonce group. - * @param nonce Nonce. - * @return list of cells resulting from the operation - * @throws IOException - */ - List get(Get get, boolean withCoprocessor, long nonceGroup, long nonce) throws IOException; - - /** * Return an iterator that scans over the HRegion, returning the indicated * columns and rows specified by the {@link Scan}. *

@@ -467,12 +351,10 @@ public interface Region extends ConfigurationObserver { /** * Perform one or more increment operations on a row. * @param increment - * @param nonceGroup - * @param nonce * @return result of the operation * @throws IOException */ - Result increment(Increment increment, long nonceGroup, long nonce) throws IOException; + Result increment(Increment increment) throws IOException; /** * Performs multiple mutations atomically on a single row. Currently @@ -535,216 +417,16 @@ public interface Region extends ConfigurationObserver { */ void put(Put put) throws IOException; - /** - * Listener class to enable callers of - * bulkLoadHFile() to perform any necessary - * pre/post processing of a given bulkload call - */ - interface BulkLoadListener { - /** - * Called before an HFile is actually loaded - * @param family family being loaded to - * @param srcPath path of HFile - * @return final path to be used for actual loading - * @throws IOException - */ - String prepareBulkLoad(byte[] family, String srcPath, boolean copyFile) - throws IOException; - - /** - * Called after a successful HFile load - * @param family family being loaded to - * @param srcPath path of HFile - * @throws IOException - */ - void doneBulkLoad(byte[] family, String srcPath) throws IOException; - - /** - * Called after a failed HFile load - * @param family family being loaded to - * @param srcPath path of HFile - * @throws IOException - */ - void failedBulkLoad(byte[] family, String srcPath) throws IOException; - } - - /** - * Attempts to atomically load a group of hfiles. This is critical for loading - * rows with multiple column families atomically. - * - * @param familyPaths List of Pair<byte[] column family, String hfilePath> - * @param bulkLoadListener Internal hooks enabling massaging/preparation of a - * file about to be bulk loaded - * @param assignSeqId - * @return Map from family to List of store file paths if successful, null if failed recoverably - * @throws IOException if failed unrecoverably. - */ - Map> bulkLoadHFiles(Collection> familyPaths, - boolean assignSeqId, BulkLoadListener bulkLoadListener) throws IOException; - - /** - * Attempts to atomically load a group of hfiles. This is critical for loading - * rows with multiple column families atomically. - * - * @param familyPaths List of Pair<byte[] column family, String hfilePath> - * @param assignSeqId - * @param bulkLoadListener Internal hooks enabling massaging/preparation of a - * file about to be bulk loaded - * @param copyFile always copy hfiles if true - * @return Map from family to List of store file paths if successful, null if failed recoverably - * @throws IOException if failed unrecoverably. - */ - Map> bulkLoadHFiles(Collection> familyPaths, - boolean assignSeqId, BulkLoadListener bulkLoadListener, boolean copyFile) throws IOException; - /////////////////////////////////////////////////////////////////////////// // Coprocessors /** @return the coprocessor host */ RegionCoprocessorHost getCoprocessorHost(); - /** - * Executes a single protocol buffer coprocessor endpoint {@link Service} method using - * the registered protocol handlers. {@link Service} implementations must be registered via the - * {@link Region#registerService(com.google.protobuf.Service)} - * method before they are available. - * - * @param controller an {@code RpcContoller} implementation to pass to the invoked service - * @param call a {@code CoprocessorServiceCall} instance identifying the service, method, - * and parameters for the method invocation - * @return a protocol buffer {@code Message} instance containing the method's result - * @throws IOException if no registered service handler is found or an error - * occurs during the invocation - * @see org.apache.hadoop.hbase.regionserver.Region#registerService(com.google.protobuf.Service) - */ - com.google.protobuf.Message execService(com.google.protobuf.RpcController controller, - CoprocessorServiceCall call) - throws IOException; - - /** - * Registers a new protocol buffer {@link Service} subclass as a coprocessor endpoint to - * be available for handling Region#execService(com.google.protobuf.RpcController, - * org.apache.hadoop.hbase.protobuf.generated.ClientProtos.CoprocessorServiceCall) calls. - * - *

- * Only a single instance may be registered per region for a given {@link Service} subclass (the - * instances are keyed on {@link com.google.protobuf.Descriptors.ServiceDescriptor#getFullName()}. - * After the first registration, subsequent calls with the same service name will fail with - * a return value of {@code false}. - *

- * @param instance the {@code Service} subclass instance to expose as a coprocessor endpoint - * @return {@code true} if the registration was successful, {@code false} - * otherwise - */ - boolean registerService(com.google.protobuf.Service instance); - - /////////////////////////////////////////////////////////////////////////// - // RowMutation processor support - - /** - * Check the collection of families for validity. - * @param families - * @throws NoSuchColumnFamilyException - */ - void checkFamilies(Collection families) throws NoSuchColumnFamilyException; - - /** - * Check the collection of families for valid timestamps - * @param familyMap - * @param now current timestamp - * @throws FailedSanityCheckException - */ - void checkTimestamps(Map> familyMap, long now) - throws FailedSanityCheckException; - - /** - * Prepare a delete for a row mutation processor - * @param delete The passed delete is modified by this method. WARNING! - * @throws IOException - */ - void prepareDelete(Delete delete) throws IOException; - - /** - * Set up correct timestamps in the KVs in Delete object. - *

Caller should have the row and region locks. - * @param mutation - * @param familyCellMap - * @param now - * @throws IOException - */ - void prepareDeleteTimestamps(Mutation mutation, Map> familyCellMap, - byte[] now) throws IOException; - - /** - * Replace any cell timestamps set to {@link org.apache.hadoop.hbase.HConstants#LATEST_TIMESTAMP} - * provided current timestamp. - * @param values - * @param now - */ - void updateCellTimestamps(final Iterable> values, final byte[] now) - throws IOException; - /////////////////////////////////////////////////////////////////////////// // Flushes, compactions, splits, etc. // Wizards only, please - interface FlushResult { - enum Result { - FLUSHED_NO_COMPACTION_NEEDED, - FLUSHED_COMPACTION_NEEDED, - // Special case where a flush didn't run because there's nothing in the memstores. Used when - // bulk loading to know when we can still load even if a flush didn't happen. - CANNOT_FLUSH_MEMSTORE_EMPTY, - CANNOT_FLUSH - } - - /** @return the detailed result code */ - Result getResult(); - - /** @return true if the memstores were flushed, else false */ - boolean isFlushSucceeded(); - - /** @return True if the flush requested a compaction, else false */ - boolean isCompactionNeeded(); - } - - /** - * Flush the cache. - * - *

When this method is called the cache will be flushed unless: - *

    - *
  1. the cache is empty
  2. - *
  3. the region is closed.
  4. - *
  5. a flush is already in progress
  6. - *
  7. writes are disabled
  8. - *
- * - *

This method may block for some time, so it should not be called from a - * time-sensitive thread. - * @param force whether we want to force a flush of all stores - * @return FlushResult indicating whether the flush was successful or not and if - * the region needs compacting - * - * @throws IOException general io exceptions - * because a snapshot was not properly persisted. - */ - FlushResult flush(boolean force) throws IOException; - - /** - * Synchronously compact all stores in the region. - *

This operation could block for a long time, so don't call it from a - * time-sensitive thread. - *

Note that no locks are taken to prevent possible conflicts between - * compaction and splitting activities. The regionserver does not normally compact - * and split in parallel. However by calling this method you may introduce - * unexpected and unhandled concurrency. Don't do this unless you know what - * you are doing. - * - * @param majorCompaction True to force a major compaction regardless of thresholds - * @throws IOException - */ - void compact(final boolean majorCompaction) throws IOException; - /** * Trigger major compaction on all stores in the region. *

@@ -771,10 +453,4 @@ public interface Region extends ConfigurationObserver { void requestCompaction(byte[] family, String why, int priority, CompactionLifeCycleTracker tracker, User user) throws IOException; - /** Wait for all current flushes and compactions of the region to complete */ - void waitForFlushesAndCompactions(); - - /** Wait for all current flushes of the region to complete - */ - void waitForFlushes(); } diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java index 84e9aa5..8fe718c 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionCoprocessorHost.java @@ -200,7 +200,7 @@ public class RegionCoprocessorHost /** The region server services */ RegionServerServices rsServices; /** The region */ - Region region; + HRegion region; /** * Constructor @@ -208,7 +208,7 @@ public class RegionCoprocessorHost * @param rsServices interface to available region server functionality * @param conf the configuration */ - public RegionCoprocessorHost(final Region region, + public RegionCoprocessorHost(final HRegion region, final RegionServerServices rsServices, final Configuration conf) { super(rsServices); this.conf = conf; 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 1d31d5a..ec1a5f1 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 @@ -23,7 +23,6 @@ import java.util.List; import java.util.Map; import java.util.concurrent.ConcurrentMap; -import org.apache.hadoop.fs.FileSystem; import org.apache.hadoop.hbase.Abortable; import org.apache.hadoop.hbase.HRegionInfo; import org.apache.hadoop.hbase.Server; @@ -85,15 +84,15 @@ public interface RegionServerServices * Context for postOpenDeployTasks(). */ class PostOpenDeployContext { - private final Region region; + private final HRegion region; private final long masterSystemTime; @InterfaceAudience.Private - public PostOpenDeployContext(Region region, long masterSystemTime) { + public PostOpenDeployContext(HRegion region, long masterSystemTime) { this.region = region; this.masterSystemTime = masterSystemTime; } - public Region getRegion() { + public HRegion getRegion() { return region; } public long getMasterSystemTime() { @@ -121,7 +120,7 @@ public interface RegionServerServices * @deprecated use {@link #postOpenDeployTasks(PostOpenDeployContext)} */ @Deprecated - void postOpenDeployTasks(final Region r) throws KeeperException, IOException; + void postOpenDeployTasks(final HRegion r) throws KeeperException, IOException; class RegionStateTransitionContext { private final TransitionCode code; @@ -194,7 +193,7 @@ public interface RegionServerServices /** * @return set of recovering regions on the hosting region server */ - Map getRecoveringRegions(); + Map getRecoveringRegions(); /** * Only required for "old" log replay; if it's removed, remove this. 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 c7d0ead..a636354 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 @@ -18,6 +18,15 @@ package org.apache.hadoop.hbase.regionserver; +import java.io.IOException; +import java.math.BigInteger; +import java.security.PrivilegedAction; +import java.security.SecureRandom; +import java.util.ArrayList; +import java.util.HashMap; +import java.util.List; +import java.util.Map; + import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; @@ -29,24 +38,17 @@ import org.apache.hadoop.fs.permission.FsPermission; import org.apache.hadoop.hbase.DoNotRetryIOException; import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; -import org.apache.yetus.audience.InterfaceAudience; import org.apache.hadoop.hbase.client.Connection; -import org.apache.hadoop.hbase.coprocessor.BulkLoadObserver; -import org.apache.hadoop.hbase.coprocessor.CoprocessorHost; -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.ipc.RpcServer; -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; -import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.PrepareBulkLoadRequest; -import org.apache.hadoop.hbase.regionserver.Region.BulkLoadListener; +import org.apache.hadoop.hbase.regionserver.HRegion.BulkLoadListener; import org.apache.hadoop.hbase.security.User; import org.apache.hadoop.hbase.security.UserProvider; import org.apache.hadoop.hbase.security.token.FsDelegationToken; import org.apache.hadoop.hbase.security.token.TokenUtil; +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; +import org.apache.hadoop.hbase.shaded.protobuf.generated.ClientProtos.PrepareBulkLoadRequest; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.FSHDFSUtils; import org.apache.hadoop.hbase.util.FSUtils; @@ -55,15 +57,7 @@ import org.apache.hadoop.hbase.util.Pair; import org.apache.hadoop.io.Text; import org.apache.hadoop.security.UserGroupInformation; import org.apache.hadoop.security.token.Token; - -import java.io.IOException; -import java.math.BigInteger; -import java.security.PrivilegedAction; -import java.security.SecureRandom; -import java.util.ArrayList; -import java.util.HashMap; -import java.util.List; -import java.util.Map; +import org.apache.yetus.audience.InterfaceAudience; /** * Bulk loads in secure mode. @@ -138,7 +132,7 @@ public class SecureBulkLoadManager { public void stop() throws IOException { } - public String prepareBulkLoad(final Region region, final PrepareBulkLoadRequest request) + public String prepareBulkLoad(final HRegion region, final PrepareBulkLoadRequest request) throws IOException { region.getCoprocessorHost().prePrepareBulkLoad(getActiveUser()); @@ -148,7 +142,7 @@ public class SecureBulkLoadManager { return bulkToken; } - public void cleanupBulkLoad(final Region region, final CleanupBulkLoadRequest request) + public void cleanupBulkLoad(final HRegion region, final CleanupBulkLoadRequest request) throws IOException { region.getCoprocessorHost().preCleanupBulkLoad(getActiveUser()); @@ -161,7 +155,7 @@ public class SecureBulkLoadManager { LOG.info("Cleaned up " + path + " successfully."); } - public Map> secureBulkLoadHFiles(final Region region, + public Map> secureBulkLoadHFiles(final HRegion region, final BulkLoadHFileRequest request) throws IOException { final List> familyPaths = new ArrayList<>(request.getFamilyPathCount()); for(ClientProtos.BulkLoadHFileRequest.FamilyPath el : request.getFamilyPathList()) { diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SplitRequest.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SplitRequest.java index c1c3f58..bb96f53 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SplitRequest.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/SplitRequest.java @@ -42,7 +42,7 @@ class SplitRequest implements Runnable { private final HRegionServer server; private final User user; - SplitRequest(Region region, byte[] midKey, HRegionServer hrs, User user) { + SplitRequest(HRegion region, byte[] midKey, HRegionServer hrs, User user) { Preconditions.checkNotNull(hrs); this.parent = region.getRegionInfo(); this.midKey = midKey; diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StorefileRefresherChore.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StorefileRefresherChore.java index ec66d55..ff41dde 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StorefileRefresherChore.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/StorefileRefresherChore.java @@ -84,7 +84,7 @@ public class StorefileRefresherChore extends ScheduledChore { @Override protected void chore() { - for (Region r : regionServer.getOnlineRegionsLocalContext()) { + for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { if (!r.isReadOnly()) { // skip checking for this region if it can accept writes continue; @@ -110,12 +110,12 @@ public class StorefileRefresherChore extends ScheduledChore { // Store files have a TTL in the archive directory. If we fail to refresh for that long, we stop serving reads if (isRegionStale(encodedName, time)) { - ((HRegion)r).setReadsEnabled(false); // stop serving reads + r.setReadsEnabled(false); // stop serving reads } continue; } lastRefreshTimes.put(encodedName, time); - ((HRegion)r).setReadsEnabled(true); // restart serving reads + r.setReadsEnabled(true); // restart serving reads } // remove closed regions diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/FlushSnapshotSubprocedure.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/FlushSnapshotSubprocedure.java index 21963d8..13ab8c8 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/FlushSnapshotSubprocedure.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/FlushSnapshotSubprocedure.java @@ -31,8 +31,7 @@ import org.apache.hadoop.hbase.errorhandling.ForeignExceptionDispatcher; import org.apache.hadoop.hbase.procedure.ProcedureMember; import org.apache.hadoop.hbase.procedure.Subprocedure; import org.apache.hadoop.hbase.regionserver.HRegion; -import org.apache.hadoop.hbase.regionserver.Region; -import org.apache.hadoop.hbase.regionserver.Region.FlushResult; +import org.apache.hadoop.hbase.regionserver.HRegion.FlushResult; import org.apache.hadoop.hbase.regionserver.Region.Operation; import org.apache.hadoop.hbase.regionserver.snapshot.RegionServerSnapshotManager.SnapshotSubprocedurePool; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotDescription; @@ -50,7 +49,7 @@ import org.apache.hadoop.hbase.snapshot.ClientSnapshotDescriptionUtils; public class FlushSnapshotSubprocedure extends Subprocedure { private static final Log LOG = LogFactory.getLog(FlushSnapshotSubprocedure.class); - private final List regions; + private final List regions; private final SnapshotDescription snapshot; private final SnapshotSubprocedurePool taskManager; private boolean snapshotSkipFlush = false; @@ -60,7 +59,7 @@ public class FlushSnapshotSubprocedure extends Subprocedure { public FlushSnapshotSubprocedure(ProcedureMember member, ForeignExceptionDispatcher errorListener, long wakeFrequency, long timeout, - List regions, SnapshotDescription snapshot, + List regions, SnapshotDescription snapshot, SnapshotSubprocedurePool taskManager) { super(member, snapshot.getName(), errorListener, wakeFrequency, timeout); this.snapshot = snapshot; @@ -76,12 +75,12 @@ public class FlushSnapshotSubprocedure extends Subprocedure { * Callable for adding files to snapshot manifest working dir. Ready for multithreading. */ public static class RegionSnapshotTask implements Callable { - private Region region; + private HRegion region; private boolean skipFlush; private ForeignExceptionDispatcher monitor; private SnapshotDescription snapshotDesc; - public RegionSnapshotTask(Region region, SnapshotDescription snapshotDesc, + public RegionSnapshotTask(HRegion region, SnapshotDescription snapshotDesc, boolean skipFlush, ForeignExceptionDispatcher monitor) { this.region = region; this.skipFlush = skipFlush; @@ -111,7 +110,7 @@ public class FlushSnapshotSubprocedure extends Subprocedure { } else { LOG.debug("Flush Snapshotting region " + region.toString() + " started..."); boolean succeeded = false; - long readPt = region.getReadpoint(IsolationLevel.READ_COMMITTED); + long readPt = region.getReadPoint(IsolationLevel.READ_COMMITTED); for (int i = 0; i < MAX_RETRIES; i++) { FlushResult res = region.flush(true); if (res.getResult() == FlushResult.Result.CANNOT_FLUSH) { @@ -132,7 +131,7 @@ public class FlushSnapshotSubprocedure extends Subprocedure { throw new IOException("Unable to complete flush after " + MAX_RETRIES + " attempts"); } } - ((HRegion)region).addRegionToSnapshot(snapshotDesc, monitor); + region.addRegionToSnapshot(snapshotDesc, monitor); if (skipFlush) { LOG.debug("... SkipFlush Snapshotting region " + region.toString() + " completed."); } else { @@ -162,7 +161,7 @@ public class FlushSnapshotSubprocedure extends Subprocedure { } // Add all hfiles already existing in region. - for (Region region : regions) { + for (HRegion region : regions) { // submit one task per region for parallelize by region. taskManager.submitTask(new RegionSnapshotTask(region, snapshot, snapshotSkipFlush, monitor)); monitor.rethrowException(); diff --git a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/RegionServerSnapshotManager.java b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/RegionServerSnapshotManager.java index 775d63f..a4b4387 100644 --- a/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/RegionServerSnapshotManager.java +++ b/hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/snapshot/RegionServerSnapshotManager.java @@ -51,6 +51,7 @@ import org.apache.hadoop.hbase.procedure.RegionServerProcedureManager; import org.apache.hadoop.hbase.procedure.Subprocedure; import org.apache.hadoop.hbase.procedure.SubprocedureFactory; import org.apache.hadoop.hbase.procedure.ZKProcedureMemberRpcs; +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.regionserver.RegionServerServices; @@ -162,7 +163,7 @@ public class RegionServerSnapshotManager extends RegionServerProcedureManager { // check to see if this server is hosting any regions for the snapshots // check to see if we have regions for the snapshot - List involvedRegions; + List involvedRegions; try { involvedRegions = getRegionsToSnapshot(snapshot); } catch (IOException e1) { @@ -222,12 +223,13 @@ public class RegionServerSnapshotManager extends RegionServerProcedureManager { * the given snapshot. * @throws IOException */ - private List getRegionsToSnapshot(SnapshotDescription snapshot) throws IOException { - List onlineRegions = rss.getRegions(TableName.valueOf(snapshot.getTable())); - Iterator iterator = onlineRegions.iterator(); + private List getRegionsToSnapshot(SnapshotDescription snapshot) throws IOException { + List onlineRegions = (List) rss + .getRegions(TableName.valueOf(snapshot.getTable())); + Iterator iterator = onlineRegions.iterator(); // remove the non-default regions while (iterator.hasNext()) { - Region r = iterator.next(); + HRegion r = iterator.next(); if (!RegionReplicaUtil.isDefaultReplica(r.getRegionInfo())) { iterator.remove(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java index 6e30246..8aee268 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/HBaseTestingUtility.java @@ -4113,8 +4113,8 @@ public class HBaseTestingUtility extends HBaseCommonTestingUtility { if (server.equals(rs.getServerName())) { continue; } - Collection hrs = rs.getOnlineRegionsLocalContext(); - for (Region r: hrs) { + Collection hrs = rs.getOnlineRegionsLocalContext(); + for (HRegion r: hrs) { assertTrue("Region should not be double assigned", r.getRegionInfo().getRegionId() != hri.getRegionId()); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java index 59a66ec..7ce4ce9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/MiniHBaseCluster.java @@ -615,7 +615,7 @@ public class MiniHBaseCluster extends HBaseCluster { public void flushcache() throws IOException { for (JVMClusterUtil.RegionServerThread t: this.hbaseCluster.getRegionServers()) { - for(Region r: t.getRegionServer().getOnlineRegionsLocalContext()) { + for (HRegion r : t.getRegionServer().getOnlineRegionsLocalContext()) { r.flush(true); } } @@ -628,8 +628,8 @@ public class MiniHBaseCluster extends HBaseCluster { public void flushcache(TableName tableName) throws IOException { for (JVMClusterUtil.RegionServerThread t: this.hbaseCluster.getRegionServers()) { - for(Region r: t.getRegionServer().getOnlineRegionsLocalContext()) { - if(r.getTableDescriptor().getTableName().equals(tableName)) { + for (HRegion r : t.getRegionServer().getOnlineRegionsLocalContext()) { + if (r.getTableDescriptor().getTableName().equals(tableName)) { r.flush(true); } } @@ -643,7 +643,7 @@ public class MiniHBaseCluster extends HBaseCluster { public void compact(boolean major) throws IOException { for (JVMClusterUtil.RegionServerThread t: this.hbaseCluster.getRegionServers()) { - for(Region r: t.getRegionServer().getOnlineRegionsLocalContext()) { + for (HRegion r : t.getRegionServer().getOnlineRegionsLocalContext()) { r.compact(major); } } @@ -656,8 +656,8 @@ public class MiniHBaseCluster extends HBaseCluster { public void compact(TableName tableName, boolean major) throws IOException { for (JVMClusterUtil.RegionServerThread t: this.hbaseCluster.getRegionServers()) { - for(Region r: t.getRegionServer().getOnlineRegionsLocalContext()) { - if(r.getTableDescriptor().getTableName().equals(tableName)) { + for (HRegion r : t.getRegionServer().getOnlineRegionsLocalContext()) { + if (r.getTableDescriptor().getTableName().equals(tableName)) { r.compact(major); } } @@ -703,9 +703,9 @@ public class MiniHBaseCluster extends HBaseCluster { List ret = new ArrayList<>(); for (JVMClusterUtil.RegionServerThread rst : getRegionServerThreads()) { HRegionServer hrs = rst.getRegionServer(); - for (Region region : hrs.getOnlineRegionsLocalContext()) { + for (HRegion region : hrs.getOnlineRegionsLocalContext()) { if (region.getTableDescriptor().getTableName().equals(tableName)) { - ret.add((HRegion)region); + ret.add(region); } } } @@ -801,9 +801,9 @@ public class MiniHBaseCluster extends HBaseCluster { ArrayList ret = new ArrayList<>(); for (JVMClusterUtil.RegionServerThread rst : getRegionServerThreads()) { HRegionServer hrs = rst.getRegionServer(); - for (Region region : hrs.getRegions(tableName)) { + for (HRegion region : hrs.getRegions(tableName)) { if (region.getTableDescriptor().getTableName().equals(tableName)) { - ret.add((HRegion)region); + ret.add(region); } } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/MockRegionServerServices.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/MockRegionServerServices.java index ef398ff..f06368f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/MockRegionServerServices.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/MockRegionServerServices.java @@ -41,6 +41,7 @@ import org.apache.hadoop.hbase.ipc.RpcServerInterface; import org.apache.hadoop.hbase.quotas.RegionServerRpcQuotaManager; import org.apache.hadoop.hbase.quotas.RegionServerSpaceQuotaManager; import org.apache.hadoop.hbase.regionserver.FlushRequester; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HeapMemoryManager; import org.apache.hadoop.hbase.regionserver.Leases; import org.apache.hadoop.hbase.regionserver.MetricsRegionServer; @@ -63,7 +64,7 @@ import org.apache.zookeeper.KeeperException; */ public class MockRegionServerServices implements RegionServerServices { protected static final Log LOG = LogFactory.getLog(MockRegionServerServices.class); - private final Map regions = new HashMap<>(); + private final Map regions = new HashMap<>(); private final ConcurrentSkipListMap rit = new ConcurrentSkipListMap<>(Bytes.BYTES_COMPARATOR); private HFileSystem hfs = null; @@ -94,7 +95,7 @@ public class MockRegionServerServices implements RegionServerServices { } @Override - public boolean removeRegion(Region r, ServerName destination) { + public boolean removeRegion(HRegion r, ServerName destination) { return this.regions.remove(r.getRegionInfo().getEncodedName()) != null; } @@ -119,12 +120,12 @@ public class MockRegionServerServices implements RegionServerServices { } @Override - public void addRegion(Region r) { + public void addRegion(HRegion r) { this.regions.put(r.getRegionInfo().getEncodedName(), r); } @Override - public void postOpenDeployTasks(Region r) throws KeeperException, IOException { + public void postOpenDeployTasks(HRegion r) throws KeeperException, IOException { addRegion(r); } @@ -267,7 +268,7 @@ public class MockRegionServerServices implements RegionServerServices { } @Override - public Map getRecoveringRegions() { + public Map getRecoveringRegions() { // TODO Auto-generated method stub return null; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestGlobalMemStoreSize.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestGlobalMemStoreSize.java index e8ae7d1..2996304 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestGlobalMemStoreSize.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestGlobalMemStoreSize.java @@ -30,8 +30,8 @@ import org.apache.commons.logging.LogFactory; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.client.RegionLocator; import org.apache.hadoop.hbase.client.Table; +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.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.MiscTests; @@ -107,7 +107,7 @@ public class TestGlobalMemStoreSize { for (HRegionInfo regionInfo : ProtobufUtil.getOnlineRegions(null, server.getRSRpcServices())) { - Region r = server.getRegion(regionInfo.getEncodedName()); + HRegion r = server.getRegion(regionInfo.getEncodedName()); flush(r, server); } LOG.info("Post flush on " + server.getServerName()); @@ -123,7 +123,7 @@ public class TestGlobalMemStoreSize { // our test was running.... for (HRegionInfo regionInfo : ProtobufUtil.getOnlineRegions(null, server.getRSRpcServices())) { - Region r = server.getRegion(regionInfo.getEncodedName()); + HRegion r = server.getRegion(regionInfo.getEncodedName()); long l = r.getMemstoreSize(); if (l > 0) { // Only meta could have edits at this stage. Give it another flush @@ -148,7 +148,7 @@ public class TestGlobalMemStoreSize { * @param server * @throws IOException */ - private void flush(final Region r, final HRegionServer server) + private void flush(final HRegion r, final HRegionServer server) throws IOException { LOG.info("Flush " + r.toString() + " on " + server.getServerName() + ", " + r.flush(true) + ", size=" + diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java index c9881c6..9efabf6 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/TestIOFencing.java @@ -288,8 +288,8 @@ public class TestIOFencing { FAMILY, Lists.newArrayList(new Path("/a")), Lists.newArrayList(new Path("/b")), new Path("store_dir")); WALUtil.writeCompactionMarker(compactingRegion.getWAL(), - ((HRegion)compactingRegion).getReplicationScope(), - oldHri, compactionDescriptor, compactingRegion.getMVCC()); + compactingRegion.getReplicationScope(), oldHri, compactionDescriptor, + compactingRegion.getMVCC()); // Wait till flush has happened, otherwise there won't be multiple store files long startWaitTime = System.currentTimeMillis(); 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 327fc89..885b1b9 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 @@ -36,11 +36,9 @@ import org.apache.hadoop.fs.PathFilter; import org.apache.hadoop.hbase.*; import org.apache.hadoop.hbase.client.Admin; 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; @@ -230,7 +228,7 @@ public class TestHFileArchiving { List servingRegions = UTIL.getHBaseCluster().getRegions(tableName); // make sure we only have 1 region serving this table assertEquals(1, servingRegions.size()); - Region region = servingRegions.get(0); + HRegion region = servingRegions.get(0); // get the parent RS and monitor HRegionServer hrs = UTIL.getRSForFirstRegionInTable(tableName); @@ -241,7 +239,7 @@ public class TestHFileArchiving { UTIL.loadRegion(region, TEST_FAM); // get the hfiles in the region - List regions = hrs.getRegions(tableName); + List regions = hrs.getRegions(tableName); assertEquals("More that 1 region for test table.", 1, regions.size()); region = regions.get(0); @@ -309,7 +307,7 @@ public class TestHFileArchiving { List servingRegions = UTIL.getHBaseCluster().getRegions(tableName); // make sure we only have 1 region serving this table assertEquals(1, servingRegions.size()); - Region region = servingRegions.get(0); + HRegion region = servingRegions.get(0); // get the parent RS and monitor HRegionServer hrs = UTIL.getRSForFirstRegionInTable(tableName); @@ -320,7 +318,7 @@ public class TestHFileArchiving { UTIL.loadRegion(region, TEST_FAM); // get the hfiles in the region - List regions = hrs.getRegions(tableName); + List regions = hrs.getRegions(tableName); assertEquals("More that 1 region for test table.", 1, regions.size()); region = regions.get(0); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/example/TestZooKeeperTableArchiveClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/example/TestZooKeeperTableArchiveClient.java index 3e8d42e..2950c1b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/example/TestZooKeeperTableArchiveClient.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/backup/example/TestZooKeeperTableArchiveClient.java @@ -48,7 +48,6 @@ import org.apache.hadoop.hbase.master.cleaner.HFileCleaner; import org.apache.hadoop.hbase.regionserver.CompactedHFilesDischarger; 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.testclassification.MiscTests; @@ -179,9 +178,9 @@ public class TestZooKeeperTableArchiveClient { // create the region ColumnFamilyDescriptor hcd = ColumnFamilyDescriptorBuilder.of(TEST_FAM); HRegion region = UTIL.createTestRegion(STRING_TABLE_NAME, hcd); - List regions = new ArrayList<>(); + List regions = new ArrayList<>(); regions.add(region); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); final CompactedHFilesDischarger compactionCleaner = new CompactedHFilesDischarger(100, stop, rss, false); loadFlushAndCompact(region, TEST_FAM); @@ -232,9 +231,9 @@ public class TestZooKeeperTableArchiveClient { // create the region ColumnFamilyDescriptor hcd = ColumnFamilyDescriptorBuilder.of(TEST_FAM); HRegion region = UTIL.createTestRegion(STRING_TABLE_NAME, hcd); - List regions = new ArrayList<>(); + List regions = new ArrayList<>(); regions.add(region); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); final CompactedHFilesDischarger compactionCleaner = new CompactedHFilesDischarger(100, stop, rss, false); loadFlushAndCompact(region, TEST_FAM); @@ -244,7 +243,7 @@ public class TestZooKeeperTableArchiveClient { HRegion otherRegion = UTIL.createTestRegion(otherTable, hcd); regions = new ArrayList<>(); regions.add(otherRegion); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); final CompactedHFilesDischarger compactionCleaner1 = new CompactedHFilesDischarger(100, stop, rss, false); loadFlushAndCompact(otherRegion, TEST_FAM); @@ -422,7 +421,7 @@ public class TestZooKeeperTableArchiveClient { * @param columnFamily family for which to add data * @throws IOException */ - private void createHFileInRegion(Region region, byte[] columnFamily) throws IOException { + private void createHFileInRegion(HRegion region, byte[] columnFamily) throws IOException { // put one row in the region Put p = new Put(Bytes.toBytes("row")); p.addColumn(columnFamily, Bytes.toBytes("Qual"), Bytes.toBytes("v1")); 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 e95f382..3fad580 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 @@ -57,8 +57,8 @@ import org.apache.hadoop.hbase.ZooKeeperConnectionException; import org.apache.hadoop.hbase.constraint.ConstraintException; import org.apache.hadoop.hbase.master.assignment.AssignmentManager; import org.apache.hadoop.hbase.master.HMaster; +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.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.testclassification.ClientTests; import org.apache.hadoop.hbase.testclassification.LargeTests; @@ -472,7 +472,7 @@ public class TestAdmin2 { + AbstractFSWALProvider.getNumRolledLogFiles(regionServer.getWAL(null)) + " log files"); // flush all regions - for (Region r : regionServer.getOnlineRegionsLocalContext()) { + for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { r.flush(true); } admin.rollWALWriter(regionServer.getServerName()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncClusterAdminApi.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncClusterAdminApi.java index 1acfcde..c35fe71 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncClusterAdminApi.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAsyncClusterAdminApi.java @@ -42,8 +42,8 @@ import org.apache.hadoop.hbase.ServerLoad; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.ClusterStatus.Option; +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.ClientTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -141,7 +141,7 @@ public class TestAsyncClusterAdminApi extends TestAsyncAdminBase { + AbstractFSWALProvider.getNumRolledLogFiles(regionServer.getWAL(null)) + " log files"); // flush all regions - for (Region r : regionServer.getOnlineRegionsLocalContext()) { + for (HRegion r : regionServer.getOnlineRegionsLocalContext()) { r.flush(true); } admin.rollWALWriter(regionServer.getServerName()).join(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java index 2d99e00..4423654 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestAvoidCellReferencesIntoShippedBlocks.java @@ -134,8 +134,7 @@ public class TestAvoidCellReferencesIntoShippedBlocks { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -313,8 +312,7 @@ public class TestAvoidCellReferencesIntoShippedBlocks { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName) - .getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestBlockEvictionFromClient.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestBlockEvictionFromClient.java index dec28f3..0992250 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestBlockEvictionFromClient.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestBlockEvictionFromClient.java @@ -184,8 +184,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName) - .getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -275,8 +274,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -334,8 +332,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -396,8 +393,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); BlockCache cache = setCacheProperties(region); Put put = new Put(ROW); put.addColumn(FAMILY, QUALIFIER, data); @@ -489,8 +485,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); BlockCache cache = setCacheProperties(region); Put put = new Put(ROW); @@ -573,8 +568,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setEvictOnClose(true); @@ -632,8 +626,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -715,8 +708,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); BlockCache cache = setCacheProperties(region); Put put = new Put(ROW); @@ -815,8 +807,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -881,8 +872,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -999,8 +989,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); @@ -1129,8 +1118,7 @@ public class TestBlockEvictionFromClient { // get the block cache and region RegionLocator locator = TEST_UTIL.getConnection().getRegionLocator(tableName); String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = - (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java index 1b1805e..be580be 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java @@ -36,7 +36,6 @@ import org.apache.hadoop.hbase.client.coprocessor.Batch; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.regionserver.MemstoreSize; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; @@ -96,7 +95,7 @@ public class TestClientPushback { BufferedMutatorImpl mutator = (BufferedMutatorImpl) conn.getBufferedMutator(tableName); HRegionServer rs = UTIL.getHBaseCluster().getRegionServer(0); - Region region = rs.getRegions(tableName).get(0); + HRegion region = rs.getRegions(tableName).get(0); LOG.debug("Writing some data to "+tableName); // write some data @@ -106,7 +105,7 @@ public class TestClientPushback { mutator.flush(); // get the current load on RS. Hopefully memstore isn't flushed since we wrote the the data - int load = (int) ((((HRegion) region).addAndGetMemstoreSize(new MemstoreSize(0, 0)) * 100) + int load = (int) ((region.addAndGetMemstoreSize(new MemstoreSize(0, 0)) * 100) / flushSizeBytes); LOG.debug("Done writing some data to "+tableName); @@ -183,7 +182,7 @@ public class TestClientPushback { ClusterConnection conn = (ClusterConnection) ConnectionFactory.createConnection(conf); Table table = conn.getTable(tableName); HRegionServer rs = UTIL.getHBaseCluster().getRegionServer(0); - Region region = rs.getRegions(tableName).get(0); + HRegion region = rs.getRegions(tableName).get(0); RowMutations mutations = new RowMutations(Bytes.toBytes("row")); Put p = new Put(Bytes.toBytes("row")); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java index 400e109..7ca9f31 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestFromClientSide.java @@ -110,7 +110,6 @@ import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.regionserver.KeyValueScanner; import org.apache.hadoop.hbase.regionserver.NoSuchColumnFamilyException; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.ScanInfo; import org.apache.hadoop.hbase.regionserver.Store; import org.apache.hadoop.hbase.regionserver.StoreScanner; @@ -4535,7 +4534,7 @@ public class TestFromClientSide { // set block size to 64 to making 2 kvs into one block, bypassing the walkForwardInSingleRow // in Store.rowAtOrBeforeFromStoreFile String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - Region region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); Put put1 = new Put(firstRow); Put put2 = new Put(secondRow); Put put3 = new Put(thirdRow); @@ -5301,8 +5300,7 @@ public class TestFromClientSide { // get the block cache and region String regionName = locator.getAllRegionLocations().get(0).getRegionInfo().getEncodedName(); - HRegion region = (HRegion) TEST_UTIL.getRSForFirstRegionInTable(tableName) - .getRegion(regionName); + HRegion region = TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegion(regionName); HStore store = region.getStores().iterator().next(); CacheConfig cacheConf = store.getCacheConfig(); cacheConf.setCacheDataOnWrite(true); 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 ca0a5ea..d08ca1d 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 @@ -44,7 +44,6 @@ import org.apache.hadoop.hbase.coprocessor.RegionObserver; import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.regionserver.MiniBatchOperationInProgress; import org.apache.hadoop.hbase.TableName; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.RegionScanner; import org.apache.hadoop.hbase.HBaseTestingUtility; import org.apache.hadoop.hbase.HColumnDescriptor; @@ -730,7 +729,7 @@ public class TestFromClientSide3 { Configuration copy = new Configuration(TEST_UTIL.getConfiguration()); copy.setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 2); try (Connection con = ConnectionFactory.createConnection(copy)) { - HRegion region = (HRegion) find(tableName); + HRegion region = find(tableName); region.setTimeoutForWriteLock(10); ExecutorService putService = Executors.newSingleThreadExecutor(); putService.execute(() -> { @@ -765,7 +764,7 @@ public class TestFromClientSide3 { assertTrue(Bytes.equals(r.getValue(FAMILY, QUALIFIER), VALUE)); } } - HRegion region = (HRegion) find(tableName); + HRegion region = find(tableName); int readLockCount = region.getReadLockCount(); LOG.info("readLockCount:" + readLockCount); assertEquals(0, readLockCount); @@ -957,20 +956,20 @@ public class TestFromClientSide3 { } private static void assertNoLocks(final TableName tableName) throws IOException, InterruptedException { - HRegion region = (HRegion) find(tableName); + HRegion region = find(tableName); assertEquals(0, region.getLockedRows().size()); } - private static Region find(final TableName tableName) + private static HRegion find(final TableName tableName) throws IOException, InterruptedException { HRegionServer rs = TEST_UTIL.getRSForFirstRegionInTable(tableName); - List regions = rs.getRegions(tableName); + List regions = rs.getRegions(tableName); assertEquals(1, regions.size()); return regions.get(0); } private static T find(final TableName tableName, Class clz) throws IOException, InterruptedException { - Region region = find(tableName); + HRegion region = find(tableName); Coprocessor cp = region.getCoprocessorHost().findCoprocessor(clz.getName()); assertTrue("The cp instance should be " + clz.getName() + ", current instance is " + cp.getClass().getName(), clz.isInstance(cp)); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHCM.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHCM.java index 1a67457..40d72b7 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHCM.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestHCM.java @@ -68,8 +68,8 @@ import org.apache.hadoop.hbase.ipc.HBaseRpcController; import org.apache.hadoop.hbase.ipc.RpcClient; import org.apache.hadoop.hbase.ipc.RpcControllerFactory; import org.apache.hadoop.hbase.master.HMaster; +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.regionserver.RegionServerStoppedException; import org.apache.hadoop.hbase.wal.WALEdit; import org.apache.hadoop.hbase.testclassification.LargeTests; @@ -1347,9 +1347,9 @@ public class TestHCM { assertTrue(!destServerName.equals(metaServerName)); //find another row in the cur server that is less than ROW_X - List regions = curServer.getRegions(TABLE_NAME3); + List regions = curServer.getRegions(TABLE_NAME3); byte[] otherRow = null; - for (Region region : regions) { + for (HRegion region : regions) { if (!region.getRegionInfo().getEncodedName().equals(toMove.getRegionInfo().getEncodedName()) && Bytes.BYTES_COMPARATOR.compare(region.getRegionInfo().getStartKey(), ROW_X) < 0) { otherRow = region.getRegionInfo().getStartKey(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java index 3b12845..e7aa60f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestMetaCache.java @@ -30,7 +30,6 @@ import org.apache.hadoop.hbase.shaded.protobuf.generated.HBaseProtos; import org.apache.hadoop.hbase.quotas.ThrottlingException; import org.apache.hadoop.hbase.regionserver.HRegionServer; import org.apache.hadoop.hbase.regionserver.RSRpcServices; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.ClientTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -248,11 +247,6 @@ public class TestMetaCache { exceptions.throwOnScan(this, request); return super.scan(controller, request); } - - public Region getRegion( - final HBaseProtos.RegionSpecifier regionSpecifier) throws IOException { - return super.getRegion(regionSpecifier); - } } public static abstract class ExceptionInjector { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorInterface.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorInterface.java index 3ff0f1f..a0a28b5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorInterface.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestCoprocessorInterface.java @@ -55,7 +55,6 @@ import org.apache.hadoop.hbase.regionserver.ChunkCreator; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.InternalScanner; import org.apache.hadoop.hbase.regionserver.MemStoreLABImpl; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.RegionCoprocessorHost; import org.apache.hadoop.hbase.regionserver.RegionScanner; import org.apache.hadoop.hbase.regionserver.ScanType; @@ -285,7 +284,7 @@ public class TestCoprocessorInterface { byte [][] families = { fam1, fam2, fam3 }; Configuration hc = initConfig(); - Region region = initHRegion(tableName, name.getMethodName(), hc, new Class[]{}, families); + HRegion region = initHRegion(tableName, name.getMethodName(), hc, new Class[]{}, families); for (int i = 0; i < 3; i++) { HBaseTestCase.addContent(region, fam3); @@ -347,7 +346,7 @@ public class TestCoprocessorInterface { byte [][] families = { fam1, fam2, fam3 }; Configuration hc = initConfig(); - Region region = initHRegion(tableName, name.getMethodName(), hc, + HRegion region = initHRegion(tableName, name.getMethodName(), hc, new Class[]{CoprocessorImpl.class}, families); for (int i = 0; i < 3; i++) { HBaseTestCase.addContent(region, fam3); @@ -374,10 +373,10 @@ public class TestCoprocessorInterface { assertTrue(((CoprocessorImpl)c).wasCompacted()); } - Region reopenRegion(final Region closedRegion, Class ... implClasses) + HRegion reopenRegion(final HRegion closedRegion, Class ... implClasses) throws IOException { //HRegionInfo info = new HRegionInfo(tableName, null, null, false); - Region r = HRegion.openHRegion(closedRegion, null); + HRegion r = HRegion.openHRegion(closedRegion, null); // this following piece is a hack. currently a coprocessorHost // is secretly loaded at OpenRegionHandler. we don't really @@ -385,7 +384,7 @@ public class TestCoprocessorInterface { // and set it to region. Configuration conf = TEST_UTIL.getConfiguration(); RegionCoprocessorHost host = new RegionCoprocessorHost(r, null, conf); - ((HRegion)r).setCoprocessorHost(host); + r.setCoprocessorHost(host); for (Class implClass : implClasses) { host.load((Class) implClass, Coprocessor.PRIORITY_USER, conf); @@ -401,7 +400,7 @@ public class TestCoprocessorInterface { return r; } - Region initHRegion (TableName tableName, String callingMethod, + HRegion initHRegion (TableName tableName, String callingMethod, Configuration conf, Class [] implClasses, byte [][] families) throws IOException { HTableDescriptor htd = new HTableDescriptor(tableName); @@ -411,11 +410,11 @@ public class TestCoprocessorInterface { ChunkCreator.initialize(MemStoreLABImpl.CHUNK_SIZE_DEFAULT, false, 0, 0, 0, null); HRegionInfo info = new HRegionInfo(tableName, null, null, false); Path path = new Path(DIR + callingMethod); - Region r = HBaseTestingUtility.createRegionAndWAL(info, path, conf, htd); + HRegion r = HBaseTestingUtility.createRegionAndWAL(info, path, conf, htd); // this following piece is a hack. RegionCoprocessorHost host = new RegionCoprocessorHost(r, null, conf); - ((HRegion)r).setCoprocessorHost(host); + r.setCoprocessorHost(host); for (Class implClass : implClasses) { host.load((Class) implClass, Coprocessor.PRIORITY_USER, conf); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java index 0446f61..966b056 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/coprocessor/TestRegionObserverScannerOpenHook.java @@ -183,7 +183,7 @@ public class TestRegionObserverScannerOpenHook { } } - Region initHRegion(byte[] tableName, String callingMethod, Configuration conf, + HRegion initHRegion(byte[] tableName, String callingMethod, Configuration conf, byte[]... families) throws IOException { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(tableName)); for (byte[] family : families) { @@ -236,7 +236,7 @@ public class TestRegionObserverScannerOpenHook { byte[][] FAMILIES = new byte[][] { A }; Configuration conf = HBaseConfiguration.create(); - Region region = initHRegion(TABLE, getClass().getName(), conf, FAMILIES); + HRegion region = initHRegion(TABLE, getClass().getName(), conf, FAMILIES); RegionCoprocessorHost h = region.getCoprocessorHost(); h.load(NoDataFromFlush.class, Coprocessor.PRIORITY_HIGHEST, conf); h.load(EmptyRegionObsever.class, Coprocessor.PRIORITY_USER, conf); @@ -320,7 +320,7 @@ public class TestRegionObserverScannerOpenHook { table.put(put); HRegionServer rs = UTIL.getRSForFirstRegionInTable(desc.getTableName()); - List regions = rs.getRegions(desc.getTableName()); + List regions = rs.getRegions(desc.getTableName()); assertEquals("More than 1 region serving test table with 1 row", 1, regions.size()); Region region = regions.get(0); admin.flushRegion(region.getRegionInfo().getRegionName()); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestFilter.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestFilter.java index 2624d95..2147e58 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestFilter.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestFilter.java @@ -71,7 +71,7 @@ import org.junit.rules.TestName; @Category({FilterTests.class, SmallTests.class}) public class TestFilter { private final static Log LOG = LogFactory.getLog(TestFilter.class); - private Region region; + private HRegion region; private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); @Rule @@ -1499,7 +1499,7 @@ public class TestFilter { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(name.getMethodName())); htd.addFamily(new HColumnDescriptor(family)); HRegionInfo info = new HRegionInfo(htd.getTableName(), null, null, false); - Region testRegion = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), + HRegion testRegion = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), TEST_UTIL.getConfiguration(), htd); for(int i=0; i<5; i++) { @@ -1534,8 +1534,8 @@ public class TestFilter { assertEquals(2, resultCount); scanner.close(); - WAL wal = ((HRegion)testRegion).getWAL(); - ((HRegion)testRegion).close(); + WAL wal = testRegion.getWAL(); + testRegion.close(); wal.close(); } @@ -2060,7 +2060,7 @@ public class TestFilter { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(name.getMethodName())); htd.addFamily(new HColumnDescriptor(FAMILIES[0])); HRegionInfo info = new HRegionInfo(htd.getTableName(), null, null, false); - Region testRegion = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), + HRegion testRegion = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), TEST_UTIL.getConfiguration(), htd); for(int i=0; i<10; i++) { Put p = new Put(Bytes.toBytes("row" + i)); @@ -2144,8 +2144,8 @@ public class TestFilter { results.clear(); } assertFalse(scanner.next(results)); - WAL wal = ((HRegion)testRegion).getWAL(); - ((HRegion)testRegion).close(); + WAL wal = testRegion.getWAL(); + testRegion.close(); wal.close(); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestInvocationRecordFilter.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestInvocationRecordFilter.java index 159769e..88b4e9f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestInvocationRecordFilter.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/filter/TestInvocationRecordFilter.java @@ -34,7 +34,6 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.InternalScanner; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.FilterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Bytes; @@ -61,7 +60,7 @@ public class TestInvocationRecordFilter { private static final String VALUE_PREFIX = "value"; private final static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); - private Region region; + private HRegion region; @Before public void setUp() throws Exception { @@ -151,8 +150,8 @@ public class TestInvocationRecordFilter { @After public void tearDown() throws Exception { - WAL wal = ((HRegion)region).getWAL(); - ((HRegion)region).close(); + WAL wal = region.getWAL(); + region.close(); wal.close(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/fs/TestBlockReorder.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/fs/TestBlockReorder.java index 706c463..2b4469c 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/fs/TestBlockReorder.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/fs/TestBlockReorder.java @@ -47,7 +47,6 @@ import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.master.LoadBalancer; 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.regionserver.wal.WALActionsListener; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.MiscTests; @@ -292,7 +291,7 @@ public class TestBlockReorder { int nbTest = 0; while (nbTest < 10) { - final List regions = targetRs.getRegions(h.getName()); + final List regions = targetRs.getRegions(h.getName()); final CountDownLatch latch = new CountDownLatch(regions.size()); // listen for successful log rolls final WALActionsListener listener = new WALActionsListener.Base() { @@ -301,8 +300,8 @@ public class TestBlockReorder { latch.countDown(); } }; - for (Region region : regions) { - ((HRegion)region).getWAL().registerWALActionsListener(listener); + for (HRegion region : regions) { + region.getWAL().registerWALActionsListener(listener); } htu.getAdmin().rollWALWriter(targetRs.getServerName()); @@ -315,8 +314,8 @@ public class TestBlockReorder { "tests fail, it's probably because we should still be waiting."); Thread.currentThread().interrupt(); } - for (Region region : regions) { - ((HRegion)region).getWAL().unregisterWALActionsListener(listener); + for (HRegion region : regions) { + region.getWAL().unregisterWALActionsListener(listener); } // We need a sleep as the namenode is informed asynchronously diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestEncodedSeekers.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestEncodedSeekers.java index efdf765..29b1cce 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestEncodedSeekers.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestEncodedSeekers.java @@ -39,7 +39,7 @@ import org.apache.hadoop.hbase.io.hfile.CacheConfig; import org.apache.hadoop.hbase.io.hfile.HFile; import org.apache.hadoop.hbase.io.hfile.LruBlockCache; import org.apache.hadoop.hbase.regionserver.BloomType; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -114,7 +114,7 @@ public class TestEncodedSeekers { setBlocksize(BLOCK_SIZE). setBloomFilterType(BloomType.NONE). setCompressTags(compressTags); - Region region = testUtil.createTestRegion(TABLE_NAME, hcd); + HRegion region = testUtil.createTestRegion(TABLE_NAME, hcd); //write the data, but leave some in the memstore doPuts(region); @@ -138,7 +138,7 @@ public class TestEncodedSeekers { } - private void doPuts(Region region) throws IOException{ + private void doPuts(HRegion region) throws IOException{ LoadTestKVGenerator dataGenerator = new LoadTestKVGenerator(MIN_VALUE_SIZE, MAX_VALUE_SIZE); for (int i = 0; i < NUM_ROWS; ++i) { byte[] key = LoadTestKVGenerator.md5PrefixedKey(i).getBytes(); @@ -168,7 +168,7 @@ public class TestEncodedSeekers { } - private void doGets(Region region) throws IOException{ + private void doGets(HRegion region) throws IOException{ for (int i = 0; i < NUM_ROWS; ++i) { final byte[] rowKey = LoadTestKVGenerator.md5PrefixedKey(i).getBytes(); for (int j = 0; j < NUM_COLS_PER_ROW; ++j) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestPrefixTree.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestPrefixTree.java index 6b13899..69e7068 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestPrefixTree.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestPrefixTree.java @@ -37,7 +37,7 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Scan; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.RegionScanner; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.SmallTests; @@ -65,7 +65,7 @@ public class TestPrefixTree { private final HBaseTestingUtility testUtil = new HBaseTestingUtility(); - private Region region; + private HRegion region; @Before public void setUp() throws Exception { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestSeekBeforeWithReverseScan.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestSeekBeforeWithReverseScan.java index 3bf189d..e0d2a9b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestSeekBeforeWithReverseScan.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/encoding/TestSeekBeforeWithReverseScan.java @@ -34,7 +34,7 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.filter.FirstKeyOnlyFilter; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.RegionScanner; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.SmallTests; @@ -48,7 +48,7 @@ import org.junit.experimental.categories.Category; public class TestSeekBeforeWithReverseScan { private final HBaseTestingUtility testUtil = new HBaseTestingUtility(); - private Region region; + private HRegion region; private byte[] cfName = Bytes.toBytes("a"); private byte[] cqName = Bytes.toBytes("b"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestCacheOnWrite.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestCacheOnWrite.java index 950beec..2b1de1e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestCacheOnWrite.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestCacheOnWrite.java @@ -55,7 +55,6 @@ import org.apache.hadoop.hbase.io.encoding.DataBlockEncoding; import org.apache.hadoop.hbase.io.hfile.bucket.BucketCache; import org.apache.hadoop.hbase.regionserver.BloomType; import org.apache.hadoop.hbase.regionserver.HRegion; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.StoreFileWriter; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.MediumTests; @@ -411,7 +410,7 @@ public class TestCacheOnWrite { final String cf = "myCF"; final byte[] cfBytes = Bytes.toBytes(cf); final int maxVersions = 3; - Region region = TEST_UTIL.createTestRegion(table, + HRegion region = TEST_UTIL.createTestRegion(table, new HColumnDescriptor(cf) .setCompressionType(compress) .setBloomFilterType(BLOOM_TYPE) @@ -456,7 +455,7 @@ public class TestCacheOnWrite { assertNotEquals(BlockType.ENCODED_DATA, block.getBlockType()); assertNotEquals(BlockType.DATA, block.getBlockType()); } - ((HRegion)region).close(); + region.close(); } @Test diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestForceCacheImportantBlocks.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestForceCacheImportantBlocks.java index e94859a..c6ae501 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestForceCacheImportantBlocks.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestForceCacheImportantBlocks.java @@ -31,7 +31,6 @@ import org.apache.hadoop.hbase.io.compress.Compression; import org.apache.hadoop.hbase.io.compress.Compression.Algorithm; import org.apache.hadoop.hbase.regionserver.BloomType; import org.apache.hadoop.hbase.regionserver.HRegion; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -127,7 +126,7 @@ public class TestForceCacheImportantBlocks { else assertTrue(stats.getMissCount() > missCount); } - private void writeTestData(Region region) throws IOException { + private void writeTestData(HRegion region) throws IOException { for (int i = 0; i < NUM_ROWS; ++i) { Put put = new Put(Bytes.toBytes("row" + i)); for (int j = 0; j < NUM_COLS_PER_ROW; ++j) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingKeyRange.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingKeyRange.java index c834fca..a36f7c9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingKeyRange.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingKeyRange.java @@ -36,8 +36,8 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Scan; import org.apache.hadoop.hbase.regionserver.BloomType; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.InternalScanner; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Bytes; @@ -99,7 +99,7 @@ public class TestScannerSelectionUsingKeyRange { HTableDescriptor htd = new HTableDescriptor(TABLE); htd.addFamily(hcd); HRegionInfo info = new HRegionInfo(TABLE); - Region region = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), conf, + HRegion region = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(), conf, htd); for (int iFile = 0; iFile < NUM_FILES; ++iFile) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingTTL.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingTTL.java index 4af48ce..f6d05b8 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingTTL.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/io/hfile/TestScannerSelectionUsingTTL.java @@ -35,9 +35,9 @@ import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Scan; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.regionserver.InternalScanner; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.IOTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -106,7 +106,7 @@ public class TestScannerSelectionUsingTTL { HTableDescriptor htd = new HTableDescriptor(TABLE); htd.addFamily(hcd); HRegionInfo info = new HRegionInfo(TABLE); - Region region = HBaseTestingUtility.createRegionAndWAL(info, + HRegion region = HBaseTestingUtility.createRegionAndWAL(info, TEST_UTIL.getDataTestDir(info.getEncodedName()), conf, htd); long ts = EnvironmentEdgeManager.currentTime(); 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 450bf8e..a8328c2 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 @@ -263,12 +263,12 @@ ClientProtos.ClientService.BlockingInterface, RegionServerServices { } @Override - public void addRegion(Region r) { + public void addRegion(HRegion r) { // TODO Auto-generated method stub } @Override - public boolean removeRegion(Region r, ServerName destination) { + public boolean removeRegion(HRegion r, ServerName destination) { // TODO Auto-generated method stub return false; } @@ -332,7 +332,7 @@ ClientProtos.ClientService.BlockingInterface, RegionServerServices { } @Override - public void postOpenDeployTasks(Region r) throws KeeperException, IOException { + public void postOpenDeployTasks(HRegion r) throws KeeperException, IOException { // TODO Auto-generated method stub } @@ -591,7 +591,7 @@ ClientProtos.ClientService.BlockingInterface, RegionServerServices { } @Override - public Map getRecoveringRegions() { + public Map getRecoveringRegions() { // TODO Auto-generated method stub return null; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentListener.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentListener.java index eaa2edb..9bda5e9 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentListener.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestAssignmentListener.java @@ -42,7 +42,6 @@ import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.master.assignment.AssignmentManager; import org.apache.hadoop.hbase.regionserver.HRegion; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.testclassification.MasterTests; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; @@ -258,8 +257,8 @@ public class TestAssignmentListener { admin.majorCompact(tableName); mergeable = 0; for (JVMClusterUtil.RegionServerThread regionThread: miniCluster.getRegionServerThreads()) { - for (Region region: regionThread.getRegionServer().getRegions(tableName)) { - mergeable += ((HRegion)region).isMergeable() ? 1 : 0; + for (HRegion region: regionThread.getRegionServer().getRegions(tableName)) { + mergeable += region.isMergeable() ? 1 : 0; } } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestGetLastFlushedSequenceId.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestGetLastFlushedSequenceId.java index 01505b8..799b927 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestGetLastFlushedSequenceId.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestGetLastFlushedSequenceId.java @@ -32,8 +32,8 @@ import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Put; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.shaded.protobuf.generated.ClusterStatusProtos.RegionStoreSequenceIds; +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.util.Bytes; import org.apache.hadoop.hbase.util.JVMClusterUtil; @@ -77,10 +77,10 @@ public class TestGetLastFlushedSequenceId { .addColumn(family, Bytes.toBytes("q"), Bytes.toBytes("v"))); MiniHBaseCluster cluster = testUtil.getMiniHBaseCluster(); List rsts = cluster.getRegionServerThreads(); - Region region = null; + HRegion region = null; for (int i = 0; i < cluster.getRegionServerThreads().size(); i++) { HRegionServer hrs = rsts.get(i).getRegionServer(); - for (Region r : hrs.getRegions(tableName)) { + for (HRegion r : hrs.getRegions(tableName)) { region = r; break; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java index c1eaef7..7220ff2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestMasterFailover.java @@ -34,7 +34,6 @@ import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.master.RegionState.State; 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.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.testclassification.FlakeyTests; import org.apache.hadoop.hbase.testclassification.LargeTests; @@ -225,9 +224,9 @@ public class TestMasterFailover { // region server should expire (how it can be verified?) MetaTableLocator.setMetaLocation(activeMaster.getZooKeeper(), rs.getServerName(), State.OPENING); - Region meta = rs.getRegion(HRegionInfo.FIRST_META_REGIONINFO.getEncodedName()); + HRegion meta = rs.getRegion(HRegionInfo.FIRST_META_REGIONINFO.getEncodedName()); rs.removeRegion(meta, null); - ((HRegion)meta).close(); + meta.close(); log("Aborting master"); activeMaster.abort("test-kill"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java index b6f3869..adf39ed 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/TestRegionPlacement.java @@ -57,6 +57,7 @@ import org.apache.hadoop.hbase.favored.FavoredNodeAssignmentHelper; import org.apache.hadoop.hbase.favored.FavoredNodeLoadBalancer; import org.apache.hadoop.hbase.favored.FavoredNodesPlan; import org.apache.hadoop.hbase.favored.FavoredNodesPlan.Position; +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.MasterTests; @@ -191,7 +192,7 @@ public class TestRegionPlacement { // kill a random non-meta server carrying at least one region killIndex = random.nextInt(SLAVES); serverToKill = TEST_UTIL.getHBaseCluster().getRegionServer(killIndex).getServerName(); - Collection regs = + Collection regs = TEST_UTIL.getHBaseCluster().getRegionServer(killIndex).getOnlineRegionsLocalContext(); isNamespaceServer = false; for (Region r : regs) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java index 4cf3fb6..d5ed9ee 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestFavoredStochasticLoadBalancer.java @@ -49,7 +49,7 @@ import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.assignment.RegionStates; import org.apache.hadoop.hbase.master.assignment.RegionStates.RegionStateNode; import org.apache.hadoop.hbase.master.ServerManager; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; @@ -544,7 +544,7 @@ public class TestFavoredStochasticLoadBalancer extends BalancerTestBase { private void compactTable(TableName tableName) throws IOException { for(JVMClusterUtil.RegionServerThread t : cluster.getRegionServerThreads()) { - for(Region region : t.getRegionServer().getRegions(tableName)) { + for(HRegion region : t.getRegionServer().getRegions(tableName)) { region.compact(true); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionLocationFinder.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionLocationFinder.java index b96dcb5..d8a8cf1 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionLocationFinder.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionLocationFinder.java @@ -31,8 +31,8 @@ import org.apache.hadoop.hbase.MiniHBaseCluster; import org.apache.hadoop.hbase.ServerName; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.client.Table; +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.MasterTests; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.apache.hadoop.hbase.util.Bytes; @@ -62,7 +62,7 @@ public class TestRegionLocationFinder { for (int i = 0; i < ServerNum; i++) { HRegionServer server = cluster.getRegionServer(i); - for (Region region : server.getRegions(tableName)) { + for (HRegion region : server.getRegions(tableName)) { region.flush(true); } } @@ -83,7 +83,7 @@ public class TestRegionLocationFinder { public void testInternalGetTopBlockLocation() throws Exception { for (int i = 0; i < ServerNum; i++) { HRegionServer server = cluster.getRegionServer(i); - for (Region region : server.getRegions(tableName)) { + for (HRegion region : server.getRegions(tableName)) { // get region's hdfs block distribution by region and RegionLocationFinder, // they should have same result HDFSBlocksDistribution blocksDistribution1 = region.getHDFSBlocksDistribution(); @@ -122,7 +122,7 @@ public class TestRegionLocationFinder { public void testGetTopBlockLocations() throws Exception { for (int i = 0; i < ServerNum; i++) { HRegionServer server = cluster.getRegionServer(i); - for (Region region : server.getRegions(tableName)) { + for (HRegion region : server.getRegions(tableName)) { List servers = finder.getTopBlockLocations(region .getRegionInfo()); // test table may have empty region @@ -147,12 +147,12 @@ public class TestRegionLocationFinder { finder.getCache().invalidateAll(); for (int i = 0; i < ServerNum; i++) { HRegionServer server = cluster.getRegionServer(i); - List regions = server.getRegions(tableName); + List regions = server.getRegions(tableName); if (regions.size() <= 0) { continue; } List regionInfos = new ArrayList<>(regions.size()); - for (Region region : regions) { + for (HRegion region : regions) { regionInfos.add(region.getRegionInfo()); } finder.refreshAndWait(regionInfos); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionsOnMasterOptions.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionsOnMasterOptions.java index 61ac2fa..47b9827 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionsOnMasterOptions.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/master/balancer/TestRegionsOnMasterOptions.java @@ -24,7 +24,7 @@ import org.apache.hadoop.hbase.*; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.LoadBalancer; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.JVMClusterUtil; import org.apache.hadoop.hbase.util.Threads; @@ -150,7 +150,7 @@ public class TestRegionsOnMasterOptions { try { Table t = TEST_UTIL.createMultiRegionTable(tn, HConstants.CATALOG_FAMILY, REGIONS); LOG.info("Server: " + cluster.getMaster().getServerManager().getOnlineServersList()); - List regions = cluster.getMaster().getRegions(); + List regions = cluster.getMaster().getRegions(); int mActualCount = regions.size(); if (masterCount == 0 || masterCount == SYSTEM_REGIONS) { // 0 means no regions on master. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestFileSystemUtilizationChore.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestFileSystemUtilizationChore.java index 60f2467..85e06ae 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestFileSystemUtilizationChore.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/quotas/TestFileSystemUtilizationChore.java @@ -36,12 +36,12 @@ import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.HBaseConfiguration; import org.apache.hadoop.hbase.HRegionInfo; import org.apache.hadoop.hbase.regionserver.HRegionServer; -import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.Store; import org.apache.hadoop.hbase.testclassification.SmallTests; import org.junit.Test; import org.junit.experimental.categories.Category; +import org.mockito.Mockito; import org.mockito.invocation.InvocationOnMock; import org.mockito.stubbing.Answer; @@ -64,7 +64,7 @@ public class TestFileSystemUtilizationChore { .reportRegionSizesForQuotas((Map) any(Map.class)); final Region region = mockRegionWithSize(regionSizes); - when(rs.getRegions()).thenReturn(Arrays.asList(region)); + Mockito.doReturn(Arrays.asList(region)).when(rs).getRegions(); chore.chore(); } @@ -81,7 +81,7 @@ public class TestFileSystemUtilizationChore { .reportRegionSizesForQuotas((Map) any(Map.class)); final Region region = mockRegionWithSize(regionSizes); - when(rs.getRegions()).thenReturn(Arrays.asList(region)); + Mockito.doReturn(Arrays.asList(region)).when(rs).getRegions(); chore.chore(); } @@ -107,7 +107,7 @@ public class TestFileSystemUtilizationChore { final Region r1 = mockRegionWithSize(r1Sizes); final Region r2 = mockRegionWithSize(r2Sizes); final Region r3 = mockRegionWithSize(r3Sizes); - when(rs.getRegions()).thenReturn(Arrays.asList(r1, r2, r3)); + Mockito.doReturn(Arrays.asList(r1, r2, r3)).when(rs).getRegions(); chore.chore(); } @@ -173,8 +173,7 @@ public class TestFileSystemUtilizationChore { final Region r1 = mockRegionWithSize(Arrays.asList(1024L, 2048L)); final Region r2 = mockRegionWithSize(Arrays.asList(1024L * 1024L)); final Region r3 = mockRegionWithSize(Arrays.asList(10L * 1024L * 1024L)); - when(rs.getRegions()).thenReturn(Arrays.asList(r1, r2, r3, lr1, lr2)); - + Mockito.doReturn(Arrays.asList(r1, r2, r3, lr1, lr2)).when(rs).getRegions(); chore.chore(); } @@ -206,8 +205,7 @@ public class TestFileSystemUtilizationChore { final Region r2 = mockRegionWithSize(Arrays.asList(1024L * 1024L)); final Region r3 = mockRegionWithSize(Arrays.asList(10L * 1024L * 1024L)); // lr2 is no longer online, so it should be ignored - when(rs.getRegions()).thenReturn(Arrays.asList(r1, r2, r3, lr1)); - + Mockito.doReturn(Arrays.asList(r1, r2, r3, lr1)).when(rs).getRegions(); chore.chore(); } @@ -229,7 +227,7 @@ public class TestFileSystemUtilizationChore { final Region r1 = mockRegionWithSize(r1Sizes); final Region r2 = mockSplitParentRegionWithSize(r2Sizes); - when(rs.getRegions()).thenReturn(Arrays.asList(r1, r2)); + Mockito.doReturn(Arrays.asList(r1, r2)).when(rs).getRegions(); chore.chore(); } @@ -251,7 +249,7 @@ public class TestFileSystemUtilizationChore { final Region r1 = mockRegionWithSize(r1Sizes); final Region r2 = mockRegionReplicaWithSize(r2Sizes); - when(rs.getRegions()).thenReturn(Arrays.asList(r1, r2)); + Mockito.doReturn(Arrays.asList(r1, r2)).when(rs).getRegions(); chore.chore(); } @@ -278,7 +276,7 @@ public class TestFileSystemUtilizationChore { final Region r1 = mockRegionWithHFileLinks(r1StoreFileSizes, r1HFileSizes); final Region r2 = mockRegionWithHFileLinks(r2StoreFileSizes, r2HFileSizes); - when(rs.getRegions()).thenReturn(Arrays.asList(r1, r2)); + Mockito.doReturn(Arrays.asList(r1, r2)).when(rs).getRegions(); chore.chore(); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java index 8f34b19..180c626 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/RegionAsTable.java @@ -25,7 +25,6 @@ import java.util.Map; import org.apache.hadoop.conf.Configuration; import org.apache.hadoop.hbase.Cell; -import org.apache.hadoop.hbase.HConstants; import org.apache.hadoop.hbase.HTableDescriptor; import org.apache.hadoop.hbase.TableName; import org.apache.hadoop.hbase.CompareOperator; @@ -270,12 +269,12 @@ public class RegionAsTable implements Table { @Override public Result append(Append append) throws IOException { - return this.region.append(append, HConstants.NO_NONCE, HConstants.NO_NONCE); + return this.region.append(append); } @Override public Result increment(Increment increment) throws IOException { - return this.region.increment(increment, HConstants.NO_NONCE, HConstants.NO_NONCE); + return this.region.increment(increment); } @Override diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java index 6a7e98b..d3ba71e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestAtomicOperation.java @@ -106,8 +106,8 @@ public class TestAtomicOperation { public void teardown() throws IOException { if (region != null) { BlockCache bc = region.getStores().get(0).getCacheConfig().getBlockCache(); - ((HRegion)region).close(); - WAL wal = ((HRegion)region).getWAL(); + region.close(); + WAL wal = region.getWAL(); if (wal != null) wal.close(); if (bc != null) bc.shutdown(); region = null; @@ -264,12 +264,12 @@ public class TestAtomicOperation { */ public static class Incrementer extends Thread { - private final Region region; + private final HRegion region; private final int numIncrements; private final int amount; - public Incrementer(Region region, int threadNumber, int amount, int numIncrements) { + public Incrementer(HRegion region, int threadNumber, int amount, int numIncrements) { super("Incrementer." + threadNumber); this.region = region; this.numIncrements = numIncrements; @@ -554,13 +554,13 @@ public class TestAtomicOperation { } public static class AtomicOperation extends Thread { - protected final Region region; + protected final HRegion region; protected final int numOps; protected final AtomicLong timeStamps; protected final AtomicInteger failures; protected final Random r = new Random(); - public AtomicOperation(Region region, int numOps, AtomicLong timeStamps, + public AtomicOperation(HRegion region, int numOps, AtomicLong timeStamps, AtomicInteger failures) { this.region = region; this.numOps = numOps; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksRead.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksRead.java index 59c256a..5c4fb60 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksRead.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksRead.java @@ -63,7 +63,7 @@ public class TestBlocksRead { BloomType.ROW, BloomType.NONE }; private static BlockCache blockCache; - Region region = null; + HRegion region = null; private static HBaseTestingUtility TEST_UTIL = new HBaseTestingUtility(); private final String DIR = TEST_UTIL.getDataTestDir("TestBlocksRead").toString(); private Configuration conf = TEST_UTIL.getConfiguration(); @@ -88,7 +88,7 @@ public class TestBlocksRead { * @throws IOException * @return created and initialized region. */ - private Region initHRegion(byte[] tableName, String callingMethod, + private HRegion initHRegion(byte[] tableName, String callingMethod, Configuration conf, String family) throws IOException { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(tableName)); HColumnDescriptor familyDesc; @@ -102,7 +102,7 @@ public class TestBlocksRead { HRegionInfo info = new HRegionInfo(htd.getTableName(), null, null, false); Path path = new Path(DIR + callingMethod); - Region r = HBaseTestingUtility.createRegionAndWAL(info, path, conf, htd); + HRegion r = HBaseTestingUtility.createRegionAndWAL(info, path, conf, htd); blockCache = new CacheConfig(conf).getBlockCache(); return r; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksScanned.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksScanned.java index c28e48b..06cbf7a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksScanned.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestBlocksScanned.java @@ -89,7 +89,7 @@ public class TestBlocksScanned extends HBaseTestCase { } private void _testBlocksScanned(HTableDescriptor table) throws Exception { - Region r = createNewHRegion(table, START_KEY, END_KEY, TEST_UTIL.getConfiguration()); + HRegion r = createNewHRegion(table, START_KEY, END_KEY, TEST_UTIL.getConfiguration()); addContent(r, FAMILY, COL); r.flush(true); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestColumnSeeking.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestColumnSeeking.java index 5cfa17d..4a26f76 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestColumnSeeking.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestColumnSeeking.java @@ -76,7 +76,7 @@ public class TestColumnSeeking { htd.addFamily(hcd); HRegionInfo info = new HRegionInfo(table, null, null, false); // Set this so that the archiver writes to the temp dir as well. - Region region = TEST_UTIL.createLocalHRegion(info, htd); + HRegion region = TEST_UTIL.createLocalHRegion(info, htd); try { List rows = generateRandomWords(10, "row"); List allColumns = generateRandomWords(10, "column"); @@ -188,7 +188,7 @@ public class TestColumnSeeking { htd.addFamily(hcd); HRegionInfo info = new HRegionInfo(table, null, null, false); - Region region = TEST_UTIL.createLocalHRegion(info, htd); + HRegion region = TEST_UTIL.createLocalHRegion(info, htd); List rows = generateRandomWords(10, "row"); List allColumns = generateRandomWords(100, "column"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveConcurrentClose.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveConcurrentClose.java index d54b58d..b4fee6a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveConcurrentClose.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveConcurrentClose.java @@ -20,7 +20,6 @@ package org.apache.hadoop.hbase.regionserver; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertFalse; import static org.mockito.Mockito.mock; -import static org.mockito.Mockito.when; import java.io.IOException; import java.io.InterruptedIOException; @@ -51,6 +50,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; import org.junit.rules.TestName; +import org.mockito.Mockito; /** * Tests a race condition between archiving of compacted files in CompactedHFilesDischarger chore @@ -90,9 +90,9 @@ public class TestCompactionArchiveConcurrentClose { HRegionInfo info = new HRegionInfo(tableName, null, null, false); HRegion region = initHRegion(htd, info); RegionServerServices rss = mock(RegionServerServices.class); - List regions = new ArrayList<>(); + List regions = new ArrayList<>(); regions.add(region); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); // Create the cleaner object CompactedHFilesDischarger cleaner = @@ -140,7 +140,7 @@ public class TestCompactionArchiveConcurrentClose { public void run() { // wait for the chore to complete and call close try { - ((HRegion) region).close(); + region.close(); } catch (IOException e) { closeException.set(e); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveIOException.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveIOException.java index 8afe85e..1557939 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveIOException.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionArchiveIOException.java @@ -27,7 +27,6 @@ import static org.mockito.Matchers.eq; import static org.mockito.Mockito.doThrow; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; -import static org.mockito.Mockito.when; import org.apache.hadoop.hbase.shaded.com.google.common.collect.ImmutableList; @@ -58,6 +57,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; import org.junit.rules.TestName; +import org.mockito.Mockito; /** * Tests that archiving compacted files behaves correctly when encountering exceptions. @@ -101,7 +101,7 @@ public class TestCompactionArchiveIOException { RegionServerServices rss = mock(RegionServerServices.class); List regions = new ArrayList<>(); regions.add(region); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); // Create the cleaner object final CompactedHFilesDischarger cleaner = diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionFileNotFound.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionFileNotFound.java index 5735e88..d21a4ef 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionFileNotFound.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionFileNotFound.java @@ -120,7 +120,7 @@ public class TestCompactionFileNotFound { Thread.sleep(1000); } table.put(putb); - HRegion hr1 = (HRegion) util.getRSForFirstRegionInTable(TEST_TABLE) + HRegion hr1 = util.getRSForFirstRegionInTable(TEST_TABLE) .getRegionByEncodedName(admin.getTableRegions(TEST_TABLE).get(0).getEncodedName()); // Refresh store files post compaction, this should not open already compacted files hr1.refreshStoreFiles(true); @@ -175,7 +175,7 @@ public class TestCompactionFileNotFound { Thread.sleep(1000); } table.put(putb); - HRegion hr1 = (HRegion) util.getRSForFirstRegionInTable(TEST_TABLE) + HRegion hr1 = util.getRSForFirstRegionInTable(TEST_TABLE) .getRegionByEncodedName(admin.getTableRegions(TEST_TABLE).get(0).getEncodedName()); // Refresh store files post compaction, this should not open already compacted files hr1.refreshStoreFiles(true); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionInDeadRegionServer.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionInDeadRegionServer.java index 4b13c30..9eb0ee5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionInDeadRegionServer.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionInDeadRegionServer.java @@ -125,7 +125,7 @@ public class TestCompactionInDeadRegionServer { @Test public void test() throws Exception { HRegionServer rsToSuspend = UTIL.getRSForFirstRegionInTable(TABLE_NAME); - HRegion region = (HRegion) rsToSuspend.getRegions(TABLE_NAME).get(0); + HRegion region = rsToSuspend.getRegions(TABLE_NAME).get(0); ZooKeeperWatcher watcher = UTIL.getZooKeeperWatcher(); watcher.getRecoverableZooKeeper().delete( ZKUtil.joinZNode(watcher.getZNodePaths().rsZNode, rsToSuspend.getServerName().toString()), diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionState.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionState.java index ac52ea4..9ebb239 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionState.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestCompactionState.java @@ -138,7 +138,7 @@ public class TestCompactionState { ht = TEST_UTIL.createTable(table, families); loadData(ht, families, 3000, flushes); HRegionServer rs = TEST_UTIL.getMiniHBaseCluster().getRegionServer(0); - List regions = rs.getRegions(table); + List regions = rs.getRegions(table); int countBefore = countStoreFilesInFamilies(regions, families); int countBeforeSingleFamily = countStoreFilesInFamily(regions, family); assertTrue(countBefore > 0); // there should be some data files @@ -168,7 +168,7 @@ public class TestCompactionState { // Now, should have the right compaction state, // otherwise, the compaction should have already been done if (expectedState != state) { - for (Region region: regions) { + for (HRegion region: regions) { state = CompactionState.valueOf(region.getCompactionState().toString()); assertEquals(CompactionState.NONE, state); } @@ -206,11 +206,11 @@ public class TestCompactionState { } private static int countStoreFilesInFamily( - List regions, final byte[] family) { + List regions, final byte[] family) { return countStoreFilesInFamilies(regions, new byte[][]{family}); } - private static int countStoreFilesInFamilies(List regions, final byte[][] families) { + private static int countStoreFilesInFamilies(List regions, final byte[][] families) { int count = 0; for (Region region: regions) { count += region.getStoreFileList(families).size(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionKeyRotation.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionKeyRotation.java index b2ef2f7..36f4cc4 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionKeyRotation.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionKeyRotation.java @@ -208,9 +208,9 @@ public class TestEncryptionKeyRotation { private static void waitForCompaction(TableName tableName) throws IOException, InterruptedException { boolean compacted = false; - for (Region region : TEST_UTIL.getRSForFirstRegionInTable(tableName) + for (HRegion region : TEST_UTIL.getRSForFirstRegionInTable(tableName) .getRegions(tableName)) { - for (HStore store : ((HRegion) region).getStores()) { + for (HStore store : region.getStores()) { compacted = false; while (!compacted) { if (store.getStorefiles() != null) { @@ -234,9 +234,9 @@ public class TestEncryptionKeyRotation { private static List findStorefilePaths(TableName tableName) throws Exception { List paths = new ArrayList<>(); - for (Region region : TEST_UTIL.getRSForFirstRegionInTable(tableName) + for (HRegion region : TEST_UTIL.getRSForFirstRegionInTable(tableName) .getRegions(tableName)) { - for (HStore store : ((HRegion) region).getStores()) { + for (HStore store : region.getStores()) { for (HStoreFile storefile : store.getStorefiles()) { paths.add(storefile.getPath()); } @@ -247,9 +247,9 @@ public class TestEncryptionKeyRotation { private static List findCompactedStorefilePaths(TableName tableName) throws Exception { List paths = new ArrayList<>(); - for (Region region : TEST_UTIL.getRSForFirstRegionInTable(tableName) + for (HRegion region : TEST_UTIL.getRSForFirstRegionInTable(tableName) .getRegions(tableName)) { - for (HStore store : ((HRegion) region).getStores()) { + for (HStore store : region.getStores()) { Collection compactedfiles = store.getStoreEngine().getStoreFileManager().getCompactedfiles(); if (compactedfiles != null) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionRandomKeying.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionRandomKeying.java index 42ef533..9906633 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionRandomKeying.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestEncryptionRandomKeying.java @@ -53,9 +53,9 @@ public class TestEncryptionRandomKeying { private static List findStorefilePaths(TableName tableName) throws Exception { List paths = new ArrayList<>(); - for (Region region: + for (HRegion region: TEST_UTIL.getRSForFirstRegionInTable(tableName).getRegions(htd.getTableName())) { - for (HStore store : ((HRegion) region).getStores()) { + for (HStore store : region.getStores()) { for (HStoreFile storefile : store.getStorefiles()) { paths.add(storefile.getPath()); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestGetClosestAtOrBefore.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestGetClosestAtOrBefore.java index 6b01256..35d985a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestGetClosestAtOrBefore.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestGetClosestAtOrBefore.java @@ -83,7 +83,7 @@ public class TestGetClosestAtOrBefore { TableDescriptorBuilder metaBuilder = UTIL.getMetaTableDescriptorBuilder() .setMemStoreFlushSize(64 * 1024 * 1024); - Region mr = HBaseTestingUtility.createRegionAndWAL(HRegionInfo.FIRST_META_REGIONINFO, + HRegion mr = HBaseTestingUtility.createRegionAndWAL(HRegionInfo.FIRST_META_REGIONINFO, rootdir, this.conf, metaBuilder.build()); try { // Write rows for three tables 'A', 'B', and 'C'. @@ -195,7 +195,7 @@ public class TestGetClosestAtOrBefore { */ @Test public void testGetClosestRowBefore3() throws IOException{ - Region region = null; + HRegion region = null; byte [] c0 = UTIL.COLUMNS[0]; byte [] c1 = UTIL.COLUMNS[1]; try { @@ -293,8 +293,8 @@ public class TestGetClosestAtOrBefore { } finally { if (region != null) { try { - WAL wal = ((HRegion)region).getWAL(); - ((HRegion)region).close(); + WAL wal = region.getWAL(); + region.close(); wal.close(); } catch (Exception e) { e.printStackTrace(); @@ -306,7 +306,7 @@ public class TestGetClosestAtOrBefore { /** For HBASE-694 */ @Test public void testGetClosestRowBefore2() throws IOException{ - Region region = null; + HRegion region = null; byte [] c0 = UTIL.COLUMNS[0]; try { TableName tn = TableName.valueOf(testName.getMethodName()); @@ -351,8 +351,8 @@ public class TestGetClosestAtOrBefore { } finally { if (region != null) { try { - WAL wal = ((HRegion)region).getWAL(); - ((HRegion)region).close(); + WAL wal = region.getWAL(); + region.close(); wal.close(); } catch (Exception e) { e.printStackTrace(); 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 9fcdf56..1b8f36c 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 @@ -5883,7 +5883,7 @@ public class TestHRegion { when(rss.getWAL((HRegionInfo) any())).thenReturn(wal); // add the region to recovering regions - HashMap recoveringRegions = Maps.newHashMap(); + HashMap recoveringRegions = Maps.newHashMap(); recoveringRegions.put(region.getRegionInfo().getEncodedName(), null); when(rss.getRecoveringRegions()).thenReturn(recoveringRegions); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java index 63f5dfc..555edc0 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestHRegionReplayEvents.java @@ -87,7 +87,7 @@ import org.junit.Rule; import org.junit.Test; import org.junit.experimental.categories.Category; import org.junit.rules.TestName; - +import org.mockito.Mockito; import org.apache.hadoop.hbase.shaded.com.google.common.collect.Lists; import org.apache.hadoop.hbase.shaded.com.google.protobuf.UnsafeByteOperations; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; @@ -180,9 +180,9 @@ public class TestHRegionReplayEvents { when(rss.getExecutorService()).thenReturn(es); primaryRegion = HRegion.createHRegion(primaryHri, rootDir, CONF, htd, walPrimary); primaryRegion.close(); - List regions = new ArrayList<>(); + List regions = new ArrayList<>(); regions.add(primaryRegion); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); primaryRegion = HRegion.openHRegion(rootDir, primaryHri, htd, walPrimary, CONF, rss, null); secondaryRegion = HRegion.openHRegion(secondaryHri, htd, null, CONF, rss, null); @@ -1186,13 +1186,13 @@ public class TestHRegionReplayEvents { @Test public void testWriteFlushRequestMarker() throws IOException { // primary region is empty at this point. Request a flush with writeFlushRequestWalMarker=false - FlushResultImpl result = (FlushResultImpl)((HRegion)primaryRegion).flushcache(true, false); + FlushResultImpl result = (FlushResultImpl)(primaryRegion).flushcache(true, false); assertNotNull(result); assertEquals(result.result, FlushResultImpl.Result.CANNOT_FLUSH_MEMSTORE_EMPTY); assertFalse(result.wroteFlushWalMarker); // request flush again, but this time with writeFlushRequestWalMarker = true - result = (FlushResultImpl)((HRegion)primaryRegion).flushcache(true, true); + result = (FlushResultImpl)(primaryRegion).flushcache(true, true); assertNotNull(result); assertEquals(result.result, FlushResultImpl.Result.CANNOT_FLUSH_MEMSTORE_EMPTY); assertTrue(result.wroteFlushWalMarker); @@ -1393,9 +1393,9 @@ public class TestHRegionReplayEvents { // Test case 3: compact primary files primaryRegion.compactStores(); - List regions = new ArrayList<>(); + List regions = new ArrayList<>(); regions.add(primaryRegion); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); CompactedHFilesDischarger cleaner = new CompactedHFilesDischarger(100, null, rss, false); cleaner.chore(); secondaryRegion.refreshStoreFiles(); 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 95a94b4..389c517 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 @@ -804,12 +804,12 @@ public class TestHeapMemoryManager { } @Override - public void requestFlush(Region region, boolean forceFlushAllStores) { + public void requestFlush(HRegion region, boolean forceFlushAllStores) { this.listener.flushRequested(flushType, region); } @Override - public void requestDelayedFlush(Region region, long delay, boolean forceFlushAllStores) { + public void requestDelayedFlush(HRegion region, long delay, boolean forceFlushAllStores) { } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestKeepDeletes.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestKeepDeletes.java index 7edcf54..71df8eb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestKeepDeletes.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestKeepDeletes.java @@ -196,7 +196,7 @@ public class TestKeepDeletes { // KEEP_DELETED_CELLS is NOT enabled HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 0, 3, HConstants.FOREVER, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); long ts = EnvironmentEdgeManager.currentTime(); Put p = new Put(T1, ts); @@ -294,7 +294,7 @@ public class TestKeepDeletes { public void testRawScanWithColumns() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 0, 3, HConstants.FOREVER, KeepDeletedCells.TRUE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); Scan s = new Scan(); s.setRaw(true); @@ -318,7 +318,7 @@ public class TestKeepDeletes { public void testRawScan() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 0, 3, HConstants.FOREVER, KeepDeletedCells.TRUE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); long ts = EnvironmentEdgeManager.currentTime(); Put p = new Put(T1, ts); @@ -592,7 +592,7 @@ public class TestKeepDeletes { public void testRanges() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 0, 3, HConstants.FOREVER, KeepDeletedCells.TRUE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); long ts = EnvironmentEdgeManager.currentTime(); Put p = new Put(T1, ts); @@ -766,7 +766,7 @@ public class TestKeepDeletes { public void testWithMixedCFs() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 0, 1, HConstants.FOREVER, KeepDeletedCells.TRUE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); long ts = EnvironmentEdgeManager.currentTime(); @@ -934,7 +934,7 @@ public class TestKeepDeletes { HBaseTestingUtility.closeRegionAndWAL(region); } - private void checkGet(Region region, byte[] row, byte[] fam, byte[] col, + private void checkGet(HRegion region, byte[] row, byte[] fam, byte[] col, long time, byte[]... vals) throws IOException { Get g = new Get(row); g.addColumn(fam, col); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java index 71f18c0..0458b0f 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMajorCompaction.java @@ -119,8 +119,8 @@ public class TestMajorCompaction { @After public void tearDown() throws Exception { - WAL wal = ((HRegion)r).getWAL(); - ((HRegion)r).close(); + WAL wal = r.getWAL(); + r.close(); wal.close(); } @@ -388,17 +388,17 @@ public class TestMajorCompaction { return count; } - private void createStoreFile(final Region region) throws IOException { + private void createStoreFile(final HRegion region) throws IOException { createStoreFile(region, Bytes.toString(COLUMN_FAMILY)); } - private void createStoreFile(final Region region, String family) throws IOException { + private void createStoreFile(final HRegion region, String family) throws IOException { Table loader = new RegionAsTable(region); HBaseTestCase.addContent(loader, family); region.flush(true); } - private void createSmallerStoreFile(final Region region) throws IOException { + private void createSmallerStoreFile(final HRegion region) throws IOException { Table loader = new RegionAsTable(region); HBaseTestCase.addContent(loader, Bytes.toString(COLUMN_FAMILY), ("" + "bbb").getBytes(), null); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinVersions.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinVersions.java index e8d60e6..4ffe5d2 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinVersions.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinVersions.java @@ -68,7 +68,7 @@ public class TestMinVersions { public void testGetClosestBefore() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 1, 1000, 1, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); try { // 2s in the past @@ -118,7 +118,7 @@ public class TestMinVersions { // keep 3 versions minimum HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 3, 1000, 1, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); // 2s in the past long ts = EnvironmentEdgeManager.currentTime() - 2000; @@ -173,7 +173,7 @@ public class TestMinVersions { public void testDelete() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 3, 1000, 1, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); // 2s in the past long ts = EnvironmentEdgeManager.currentTime() - 2000; @@ -232,7 +232,7 @@ public class TestMinVersions { public void testMemStore() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 2, 1000, 1, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); // 2s in the past long ts = EnvironmentEdgeManager.currentTime() - 2000; @@ -308,7 +308,7 @@ public class TestMinVersions { // 1 version minimum, 1000 versions maximum, ttl = 1s HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 2, 1000, 1, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); try { // 2s in the past @@ -400,7 +400,7 @@ public class TestMinVersions { public void testFilters() throws Exception { HTableDescriptor htd = hbu.createTableDescriptor(name.getMethodName(), 2, 1000, 1, KeepDeletedCells.FALSE); - Region region = hbu.createLocalHRegion(htd, null, null); + HRegion region = hbu.createLocalHRegion(htd, null, null); final byte [] c1 = COLUMNS[1]; // 2s in the past diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinorCompaction.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinorCompaction.java index a7b5cd5..2e43218 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinorCompaction.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestMinorCompaction.java @@ -89,8 +89,8 @@ public class TestMinorCompaction { @After public void tearDown() throws Exception { - WAL wal = ((HRegion)r).getWAL(); - ((HRegion)r).close(); + WAL wal = r.getWAL(); + r.close(); wal.close(); } 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 d22046c..f1a66e7 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 @@ -145,7 +145,7 @@ public class TestMultiColumnScanner { @Test public void testMultiColumnScanner() throws IOException { - Region region = TEST_UTIL.createTestRegion(TABLE_NAME, + HRegion region = TEST_UTIL.createTestRegion(TABLE_NAME, new HColumnDescriptor(FAMILY) .setCompressionType(comprAlgo) .setBloomFilterType(bloomType) diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestPerColumnFamilyFlush.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestPerColumnFamilyFlush.java index a0d953e..aaef081 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestPerColumnFamilyFlush.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestPerColumnFamilyFlush.java @@ -46,7 +46,6 @@ import org.apache.hadoop.hbase.util.JVMClusterUtil; import org.apache.hadoop.hbase.util.Pair; import org.apache.hadoop.hbase.wal.AbstractFSWALProvider; import org.apache.hadoop.hbase.wal.WAL; -import org.junit.Before; import org.junit.Ignore; import org.junit.Test; import org.junit.experimental.categories.Category; @@ -131,7 +130,7 @@ public class TestPerColumnFamilyFlush { conf.setLong(FlushLargeStoresPolicy.HREGION_COLUMNFAMILY_FLUSH_SIZE_LOWER_BOUND_MIN, 40 * 1024); // Intialize the region - Region region = initHRegion("testSelectiveFlushWithDataCompaction", conf); + HRegion region = initHRegion("testSelectiveFlushWithDataCompaction", conf); // Add 1200 entries for CF1, 100 for CF2 and 50 for CF3 for (int i = 1; i <= 1200; i++) { region.put(createPut(1, i)); @@ -325,12 +324,12 @@ public class TestPerColumnFamilyFlush { } // Find the (first) region which has the specified name. - private static Pair getRegionWithName(TableName tableName) { + private static Pair getRegionWithName(TableName tableName) { MiniHBaseCluster cluster = TEST_UTIL.getMiniHBaseCluster(); List rsts = cluster.getRegionServerThreads(); for (int i = 0; i < cluster.getRegionServerThreads().size(); i++) { HRegionServer hrs = rsts.get(i).getRegionServer(); - for (Region region : hrs.getRegions(tableName)) { + for (HRegion region : hrs.getRegions(tableName)) { return Pair.newPair(region, hrs); } } @@ -368,8 +367,8 @@ public class TestPerColumnFamilyFlush { } Thread.sleep(1000); - Pair desiredRegionAndServer = getRegionWithName(TABLENAME); - Region desiredRegion = desiredRegionAndServer.getFirst(); + Pair desiredRegionAndServer = getRegionWithName(TABLENAME); + HRegion desiredRegion = desiredRegionAndServer.getFirst(); assertTrue("Could not find a region which hosts the new region.", desiredRegion != null); // Flush the region selectively. @@ -435,11 +434,11 @@ public class TestPerColumnFamilyFlush { doTestLogReplay(); } - private WAL getWAL(Region region) { - return ((HRegion)region).getWAL(); + private WAL getWAL(HRegion region) { + return region.getWAL(); } - private int getNumRolledLogFiles(Region region) { + private int getNumRolledLogFiles(HRegion region) { return AbstractFSWALProvider.getNumRolledLogFiles(getWAL(region)); } @@ -477,8 +476,8 @@ public class TestPerColumnFamilyFlush { try (Admin admin = TEST_UTIL.getConnection().getAdmin()) { admin.flush(TableName.NAMESPACE_TABLE_NAME); } - Pair desiredRegionAndServer = getRegionWithName(tableName); - final Region desiredRegion = desiredRegionAndServer.getFirst(); + Pair desiredRegionAndServer = getRegionWithName(tableName); + final HRegion desiredRegion = desiredRegionAndServer.getFirst(); assertTrue("Could not find a region which hosts the new region.", desiredRegion != null); LOG.info("Writing to region=" + desiredRegion); @@ -540,7 +539,7 @@ public class TestPerColumnFamilyFlush { } private void doPut(Table table, long memstoreFlushSize) throws IOException, InterruptedException { - Region region = getRegionWithName(table.getName()).getFirst(); + HRegion region = getRegionWithName(table.getName()).getFirst(); // cf1 4B per row, cf2 40B per row and cf3 400B per row byte[] qf = Bytes.toBytes("qf"); Random rand = new Random(); @@ -601,7 +600,7 @@ public class TestPerColumnFamilyFlush { table.close(); conn.close(); - Region region = getRegionWithName(TABLENAME).getFirst(); + HRegion region = getRegionWithName(TABLENAME).getFirst(); cf1StoreFileCount = region.getStore(FAMILY1).getStorefilesCount(); cf2StoreFileCount = region.getStore(FAMILY2).getStorefilesCount(); cf3StoreFileCount = region.getStore(FAMILY3).getStorefilesCount(); @@ -624,7 +623,7 @@ public class TestPerColumnFamilyFlush { table.close(); conn.close(); - Region region = getRegionWithName(TABLENAME).getFirst(); + HRegion region = getRegionWithName(TABLENAME).getFirst(); cf1StoreFileCount1 = region.getStore(FAMILY1).getStorefilesCount(); cf2StoreFileCount1 = region.getStore(FAMILY2).getStorefilesCount(); cf3StoreFileCount1 = region.getStore(FAMILY3).getStorefilesCount(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionFavoredNodes.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionFavoredNodes.java index b2b03ff..b98ac2a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionFavoredNodes.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionFavoredNodes.java @@ -114,8 +114,8 @@ public class TestRegionFavoredNodes { // them as favored nodes through the region. for (int i = 0; i < REGION_SERVERS; i++) { HRegionServer server = TEST_UTIL.getHBaseCluster().getRegionServer(i); - List regions = server.getRegions(TABLE_NAME); - for (Region region : regions) { + List regions = server.getRegions(TABLE_NAME); + for (HRegion region : regions) { ListfavoredNodes = new ArrayList<>(3); String encodedRegionName = region.getRegionInfo().getEncodedName(); @@ -142,8 +142,8 @@ public class TestRegionFavoredNodes { // they are consistent with the favored nodes for that region. for (int i = 0; i < REGION_SERVERS; i++) { HRegionServer server = TEST_UTIL.getHBaseCluster().getRegionServer(i); - List regions = server.getRegions(TABLE_NAME); - for (Region region : regions) { + List regions = server.getRegions(TABLE_NAME); + for (HRegion region : regions) { List files = region.getStoreFileList(new byte[][]{COLUMN_FAMILY}); for (String file : files) { FileStatus status = TEST_UTIL.getDFSCluster().getFileSystem(). diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionIncrement.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionIncrement.java index 394b8a2..fa5d3eb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionIncrement.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionIncrement.java @@ -84,7 +84,7 @@ public class TestRegionIncrement { WAL wal = new FSHLog(FileSystem.get(conf), TEST_UTIL.getDataTestDir(), TEST_UTIL.getDataTestDir().toString(), conf); ChunkCreator.initialize(MemStoreLABImpl.CHUNK_SIZE_DEFAULT, false, 0, 0, 0, null); - return (HRegion)TEST_UTIL.createLocalHRegion(Bytes.toBytes(tableName), + return TEST_UTIL.createLocalHRegion(Bytes.toBytes(tableName), HConstants.EMPTY_BYTE_ARRAY, HConstants.EMPTY_BYTE_ARRAY, tableName, conf, false, Durability.SKIP_WAL, wal, INCREMENT_BYTES); } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicaFailover.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicaFailover.java index ffcc5c0..80aaab0 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicaFailover.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicaFailover.java @@ -185,7 +185,7 @@ public class TestRegionReplicaFailover { // read from it the same data from primary and secondaries boolean aborted = false; for (RegionServerThread rs : HTU.getMiniHBaseCluster().getRegionServerThreads()) { - for (Region r : rs.getRegionServer().getRegions(htd.getTableName())) { + for (HRegion r : rs.getRegionServer().getRegions(htd.getTableName())) { if (r.getRegionInfo().getReplicaId() == 0) { LOG.info("Aborting region server hosting primary region replica"); rs.getRegionServer().abort("for test"); @@ -247,7 +247,7 @@ public class TestRegionReplicaFailover { // read from it the same data boolean aborted = false; for (RegionServerThread rs : HTU.getMiniHBaseCluster().getRegionServerThreads()) { - for (Region r : rs.getRegionServer().getRegions(htd.getTableName())) { + for (HRegion r : rs.getRegionServer().getRegions(htd.getTableName())) { if (r.getRegionInfo().getReplicaId() == 1) { LOG.info("Aborting region server hosting secondary region replica"); rs.getRegionServer().abort("for test"); @@ -308,7 +308,7 @@ public class TestRegionReplicaFailover { try { boolean aborted = false; for (RegionServerThread rs : HTU.getMiniHBaseCluster().getRegionServerThreads()) { - for (Region r : rs.getRegionServer().getRegions(htd.getTableName())) { + for (HRegion r : rs.getRegionServer().getRegions(htd.getTableName())) { if (r.getRegionInfo().getReplicaId() == 1) { LOG.info("Aborting region server hosting secondary region replica"); rs.getRegionServer().abort("for test"); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicas.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicas.java index 5d2b9c1..432bf02 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicas.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionReplicas.java @@ -156,7 +156,7 @@ public class TestRegionReplicas { // assert that we can read back from primary Assert.assertEquals(1000, HTU.countRows(table)); // flush so that region replica can read - Region region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); + HRegion region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); region.flush(true); openRegion(HTU, getRS(), hriSecondary); @@ -180,7 +180,7 @@ public class TestRegionReplicas { // assert that we can read back from primary Assert.assertEquals(1000, HTU.countRows(table)); // flush so that region replica can read - Region region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); + HRegion region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); region.flush(true); openRegion(HTU, getRS(), hriSecondary); @@ -250,9 +250,8 @@ public class TestRegionReplicas { Assert.assertEquals(1000, HTU.countRows(table)); // flush so that region replica can read LOG.info("Flushing primary region"); - Region region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); + HRegion region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); region.flush(true); - HRegion primaryRegion = (HRegion) region; // ensure that chore is run LOG.info("Sleeping for " + (4 * refreshPeriod)); @@ -442,11 +441,11 @@ public class TestRegionReplicas { LOG.info("Loading data to primary region"); for (int i = 0; i < 3; ++i) { HTU.loadNumericRows(table, f, i * 1000, (i + 1) * 1000); - Region region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); + HRegion region = getRS().getRegionByEncodedName(hriPrimary.getEncodedName()); region.flush(true); } - Region primaryRegion = getRS().getRegion(hriPrimary.getEncodedName()); + HRegion primaryRegion = getRS().getRegion(hriPrimary.getEncodedName()); Assert.assertEquals(3, primaryRegion.getStore(f).getStorefilesCount()); // Refresh store files on the secondary 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 6d8744b..fdf4483 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 @@ -496,7 +496,7 @@ public class TestRegionServerMetrics { byte[] val = Bytes.toBytes("mobdata"); try { Table table = TEST_UTIL.createTable(htd, new byte[0][0], conf); - Region region = rs.getRegions(tableName).get(0); + HRegion region = rs.getRegions(tableName).get(0); for (int insertCount = 0; insertCount < numHfiles; insertCount++) { Put p = new Put(Bytes.toBytes(insertCount)); p.addColumn(cf, qualifier, val); @@ -515,7 +515,7 @@ public class TestRegionServerMetrics { setMobThreshold(region, cf, 100); // metrics are reset by the region initialization - ((HRegion) region).initialize(); + region.initialize(); region.compact(true); metricsRegionServer.getRegionServerWrapper().forceRecompute(); assertCounter("cellsCountCompactedFromMob", numHfiles); @@ -536,10 +536,10 @@ public class TestRegionServerMetrics { setMobThreshold(region, cf, 0); // closing the region forces the compaction.discharger to archive the compacted hfiles - ((HRegion) region).close(); + region.close(); // metrics are reset by the region initialization - ((HRegion) region).initialize(); + region.initialize(); region.compact(true); metricsRegionServer.getRegionServerWrapper().forceRecompute(); // metrics are reset by the region initialization @@ -551,7 +551,7 @@ public class TestRegionServerMetrics { } } - private static Region setMobThreshold(Region region, byte[] cfName, long modThreshold) { + private static Region setMobThreshold(HRegion region, byte[] cfName, long modThreshold) { ColumnFamilyDescriptor cfd = ColumnFamilyDescriptorBuilder .newBuilder(region.getTableDescriptor().getColumnFamily(cfName)) .setMobThreshold(modThreshold) @@ -561,7 +561,7 @@ public class TestRegionServerMetrics { .removeColumnFamily(cfName) .addColumnFamily(cfd) .build(); - ((HRegion)region).setTableDescriptor(td); + region.setTableDescriptor(td); return region; } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerNoMaster.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerNoMaster.java index 3b66a1d..ffda964 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerNoMaster.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionServerNoMaster.java @@ -129,7 +129,7 @@ public class TestRegionServerNoMaster { /** Flush the given region in the mini cluster. Since no master, we cannot use HBaseAdmin.flush() */ public static void flushRegion(HBaseTestingUtility HTU, HRegionInfo regionInfo) throws IOException { for (RegionServerThread rst : HTU.getMiniHBaseCluster().getRegionServerThreads()) { - Region region = rst.getRegionServer().getRegionByEncodedName(regionInfo.getEncodedName()); + HRegion region = rst.getRegionServer().getRegionByEncodedName(regionInfo.getEncodedName()); if (region != null) { region.flush(true); return; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java index 2b79152..d156456 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRegionSplitPolicy.java @@ -105,7 +105,7 @@ public class TestRegionSplitPolicy { // return 'online regions'. RegionServerServices rss = Mockito.mock(RegionServerServices.class); final List regions = new ArrayList<>(); - Mockito.when(rss.getRegions(TABLENAME)).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(TABLENAME); Mockito.when(mockRegion.getRegionServerServices()).thenReturn(rss); // Set max size for this 'table'. long maxSplitSize = 1024L; @@ -164,7 +164,7 @@ public class TestRegionSplitPolicy { RegionServerServices rss = Mockito.mock(RegionServerServices.class); final List regions = new ArrayList<>(); - Mockito.when(rss.getRegions(TABLENAME)).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(TABLENAME); Mockito.when(mockRegion.getRegionServerServices()).thenReturn(rss); Mockito.when(mockRegion.getBlockedRequestsCount()).thenReturn(0L); Mockito.when(mockRegion.getWriteRequestsCount()).thenReturn(0L); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestResettingCounters.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestResettingCounters.java index 3a952ee..570422e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestResettingCounters.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestResettingCounters.java @@ -73,7 +73,7 @@ public class TestResettingCounters { throw new IOException("Failed delete of " + path); } } - Region region = HBaseTestingUtility.createRegionAndWAL(hri, path, conf, htd); + HRegion region = HBaseTestingUtility.createRegionAndWAL(hri, path, conf, htd); try { Increment odd = new Increment(rows[0]); odd.setDurability(Durability.SKIP_WAL); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestReversibleScanners.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestReversibleScanners.java index dbf3be0..63e549e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestReversibleScanners.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestReversibleScanners.java @@ -321,7 +321,7 @@ public class TestReversibleScanners { HTableDescriptor htd = new HTableDescriptor(TableName.valueOf(name.getMethodName())) .addFamily(new HColumnDescriptor(FAMILYNAME)) .addFamily(new HColumnDescriptor(FAMILYNAME2)); - Region region = TEST_UTIL.createLocalHRegion(htd, null, null); + HRegion region = TEST_UTIL.createLocalHRegion(htd, null, null); loadDataToRegion(region, FAMILYNAME2); // verify row count with forward scan @@ -641,7 +641,7 @@ public class TestReversibleScanners { return nextReadableNum; } - private static void loadDataToRegion(Region region, byte[] additionalFamily) + private static void loadDataToRegion(HRegion region, byte[] additionalFamily) throws IOException { for (int i = 0; i < ROWSIZE; i++) { Put put = new Put(ROWS[i]); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowTooBig.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowTooBig.java index 4d3a1c3..f9d0d1a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowTooBig.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestRowTooBig.java @@ -85,7 +85,7 @@ public class TestRowTooBig { final HRegionInfo hri = new HRegionInfo(htd.getTableName(), HConstants.EMPTY_END_ROW, HConstants.EMPTY_END_ROW); - Region region = + HRegion region = HBaseTestingUtility.createRegionAndWAL(hri, rootRegionDir, HTU.getConfiguration(), htd); try { // Add 5 cells to memstore @@ -132,7 +132,7 @@ public class TestRowTooBig { final HRegionInfo hri = new HRegionInfo(htd.getTableName(), HConstants.EMPTY_END_ROW, HConstants.EMPTY_END_ROW); - Region region = + HRegion region = HBaseTestingUtility.createRegionAndWAL(hri, rootRegionDir, HTU.getConfiguration(), htd); try { // Add to memstore 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 72267be..e01b59d 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 @@ -75,7 +75,7 @@ public class TestScanWithBloomError { private static final String QUALIFIER_PREFIX = "qual"; private static final byte[] ROW_BYTES = Bytes.toBytes(ROW); private static NavigableSet allColIds = new TreeSet<>(); - private Region region; + private HRegion region; private BloomType bloomType; private FileSystem fs; private Configuration conf; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanner.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanner.java index d9fd3de..ad53abb 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanner.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestScanner.java @@ -274,7 +274,7 @@ public class TestScanner { // Close and re-open - ((HRegion)region).close(); + region.close(); region = HRegion.openHRegion(region, null); table = new RegionAsTable(region); @@ -311,7 +311,7 @@ public class TestScanner { // Close and reopen - ((HRegion)region).close(); + region.close(); region = HRegion.openHRegion(region,null); table = new RegionAsTable(region); @@ -345,7 +345,7 @@ public class TestScanner { // Close and reopen - ((HRegion)this.region).close(); + this.region.close(); this.region = HRegion.openHRegion(region, null); table = new RegionAsTable(this.region); 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 67f6f34..03860f2 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 @@ -107,7 +107,7 @@ public class TestSeekOptimizations { private static final int[] MAX_VERSIONS_VALUES = new int[] { 1, 2 }; // Instance variables - private Region region; + private HRegion region; private Put put; private Delete del; private Random rand; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitWalDataLoss.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitWalDataLoss.java index fecfd94..f1b1ee5 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitWalDataLoss.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestSplitWalDataLoss.java @@ -44,7 +44,7 @@ import org.apache.hadoop.hbase.client.Result; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.monitoring.MonitoredTask; import org.apache.hadoop.hbase.regionserver.HRegion.PrepareFlushResult; -import org.apache.hadoop.hbase.regionserver.Region.FlushResult; +import org.apache.hadoop.hbase.regionserver.HRegion.FlushResult; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.EnvironmentEdgeManager; @@ -95,7 +95,7 @@ public class TestSplitWalDataLoss { @Test public void test() throws IOException, InterruptedException { final HRegionServer rs = testUtil.getRSForFirstRegionInTable(tableName); - final HRegion region = (HRegion) rs.getRegions(tableName).get(0); + final HRegion region = rs.getRegions(tableName).get(0); HRegion spiedRegion = spy(region); final MutableBoolean flushed = new MutableBoolean(false); final MutableBoolean reported = new MutableBoolean(false); @@ -120,7 +120,7 @@ public class TestSplitWalDataLoss { Matchers.> any()); // Find region key; don't pick up key for hbase:meta by mistake. String key = null; - for (Map.Entry entry: rs.onlineRegions.entrySet()) { + for (Map.Entry entry: rs.onlineRegions.entrySet()) { if (entry.getValue().getRegionInfo().getTable().equals(this.tableName)) { key = entry.getKey(); break; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStoreFileRefresherChore.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStoreFileRefresherChore.java index 5ac7efb..2c0ddf0 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStoreFileRefresherChore.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestStoreFileRefresherChore.java @@ -99,7 +99,7 @@ public class TestStoreFileRefresherChore { } } - private Region initHRegion(HTableDescriptor htd, byte[] startKey, byte[] stopKey, int replicaId) + private HRegion initHRegion(HTableDescriptor htd, byte[] startKey, byte[] stopKey, int replicaId) throws IOException { Configuration conf = TEST_UTIL.getConfiguration(); Path tableDir = FSUtils.getTableDir(testDir, htd.getTableName()); @@ -171,14 +171,14 @@ public class TestStoreFileRefresherChore { byte[] qf = Bytes.toBytes("cq"); HRegionServer regionServer = mock(HRegionServer.class); - List regions = new ArrayList<>(); + List regions = new ArrayList<>(); when(regionServer.getOnlineRegionsLocalContext()).thenReturn(regions); when(regionServer.getConfiguration()).thenReturn(TEST_UTIL.getConfiguration()); HTableDescriptor htd = getTableDesc(TableName.valueOf(name.getMethodName()), families); htd.setRegionReplication(2); - Region primary = initHRegion(htd, HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW, 0); - Region replica1 = initHRegion(htd, HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW, 1); + HRegion primary = initHRegion(htd, HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW, 0); + HRegion replica1 = initHRegion(htd, HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW, 1); regions.add(primary); regions.add(replica1); @@ -199,7 +199,7 @@ public class TestStoreFileRefresherChore { verifyData(replica1, 0, 100, qf, families); // simulate an fs failure where we cannot refresh the store files for the replica - ((FailingHRegionFileSystem)((HRegion)replica1).getRegionFileSystem()).fail = true; + ((FailingHRegionFileSystem)(replica1).getRegionFileSystem()).fail = true; // write some more data to primary and flush putData(primary, 100, 100, qf, families); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWALMonotonicallyIncreasingSeqId.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWALMonotonicallyIncreasingSeqId.java index fabd075..1176352 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWALMonotonicallyIncreasingSeqId.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWALMonotonicallyIncreasingSeqId.java @@ -83,7 +83,7 @@ public class TestWALMonotonicallyIncreasingSeqId { return htd; } - private Region initHRegion(HTableDescriptor htd, byte[] startKey, byte[] stopKey, int replicaId) + private HRegion initHRegion(HTableDescriptor htd, byte[] startKey, byte[] stopKey, int replicaId) throws IOException { Configuration conf = TEST_UTIL.getConfiguration(); conf.setBoolean("hbase.hregion.mvcc.preassign", false); @@ -161,7 +161,7 @@ public class TestWALMonotonicallyIncreasingSeqId { byte[][] families = new byte[][] {Bytes.toBytes("cf")}; byte[] qf = Bytes.toBytes("cq"); HTableDescriptor htd = getTableDesc(TableName.valueOf(name.getMethodName()), families); - HRegion region = (HRegion)initHRegion(htd, HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW, 0); + HRegion region = initHRegion(htd, HConstants.EMPTY_START_ROW, HConstants.EMPTY_END_ROW, 0); List putThreads = new ArrayList<>(); for(int i = 0; i < 1; i++) { putThreads.add(new PutThread(region)); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWalAndCompactingMemStoreFlush.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWalAndCompactingMemStoreFlush.java index 6dc1a1b..6104059 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWalAndCompactingMemStoreFlush.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/TestWalAndCompactingMemStoreFlush.java @@ -107,10 +107,10 @@ public class TestWalAndCompactingMemStoreFlush { return new Get(row); } - private void verifyInMemoryFlushSize(Region region) { + private void verifyInMemoryFlushSize(HRegion region) { assertEquals( - ((CompactingMemStore) ((HStore)region.getStore(FAMILY1)).memstore).getInmemoryFlushSize(), - ((CompactingMemStore) ((HStore)region.getStore(FAMILY3)).memstore).getInmemoryFlushSize()); + ((CompactingMemStore) region.getStore(FAMILY1).memstore).getInmemoryFlushSize(), + ((CompactingMemStore) region.getStore(FAMILY3).memstore).getInmemoryFlushSize()); } // A helper function to verify edits. @@ -141,7 +141,7 @@ public class TestWalAndCompactingMemStoreFlush { String.valueOf(MemoryCompactionPolicy.EAGER)); // Intialize the region - Region region = initHRegion("testSelectiveFlushWithEager", conf); + HRegion region = initHRegion("testSelectiveFlushWithEager", conf); verifyInMemoryFlushSize(region); // Add 1200 entries for CF1, 100 for CF2 and 50 for CF3 for (int i = 1; i <= 1200; i++) { @@ -382,7 +382,7 @@ public class TestWalAndCompactingMemStoreFlush { String.valueOf(MemoryCompactionPolicy.BASIC)); // Initialize the region - Region region = initHRegion("testSelectiveFlushWithIndexCompaction", conf); + HRegion region = initHRegion("testSelectiveFlushWithIndexCompaction", conf); verifyInMemoryFlushSize(region); /*------------------------------------------------------------------------------*/ /* PHASE I - insertions */ @@ -1022,7 +1022,7 @@ public class TestWalAndCompactingMemStoreFlush { } } - private WAL getWAL(Region region) { - return ((HRegion)region).getWAL(); + private WAL getWAL(HRegion region) { + return region.getWAL(); } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestCompactedHFilesDischarger.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestCompactedHFilesDischarger.java index 5afa52f..ca44ce4 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestCompactedHFilesDischarger.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestCompactedHFilesDischarger.java @@ -21,7 +21,6 @@ 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.ArrayList; @@ -54,6 +53,7 @@ import org.junit.After; import org.junit.Before; import org.junit.Test; import org.junit.experimental.categories.Category; +import org.mockito.Mockito; @Category({ MediumTests.class, RegionServerTests.class }) public class TestCompactedHFilesDischarger { @@ -78,7 +78,7 @@ public class TestCompactedHFilesDischarger { rss = mock(RegionServerServices.class); List regions = new ArrayList<>(1); regions.add(region); - when(rss.getRegions()).thenReturn(regions); + Mockito.doReturn(regions).when(rss).getRegions(); } @After @@ -345,7 +345,7 @@ public class TestCompactedHFilesDischarger { // Start parallel scan threads ScanThread[] scanThreads = new ScanThread[3]; for (int i = 0; i < 3; i++) { - scanThreads[i] = new ScanThread((HRegion) region); + scanThreads[i] = new ScanThread(region); } for (ScanThread thread : scanThreads) { thread.start(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestFIFOCompactionPolicy.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestFIFOCompactionPolicy.java index 166fede..462160a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestFIFOCompactionPolicy.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/compactions/TestFIFOCompactionPolicy.java @@ -40,7 +40,6 @@ import org.apache.hadoop.hbase.regionserver.DisabledRegionSplitPolicy; 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.regionserver.Region; import org.apache.hadoop.hbase.testclassification.MediumTests; import org.apache.hadoop.hbase.testclassification.RegionServerTests; import org.apache.hadoop.hbase.util.Bytes; @@ -71,8 +70,8 @@ public class TestFIFOCompactionPolicy { List rsts = cluster.getRegionServerThreads(); for (int i = 0; i < cluster.getRegionServerThreads().size(); i++) { HRegionServer hrs = rsts.get(i).getRegionServer(); - for (Region region : hrs.getRegions(tableName)) { - return ((HRegion) region).getStores().iterator().next(); + for (HRegion region : hrs.getRegions(tableName)) { + return region.getStores().iterator().next(); } } return null; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestCompactionWithThroughputController.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestCompactionWithThroughputController.java index fe33d86..41f71bf 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestCompactionWithThroughputController.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestCompactionWithThroughputController.java @@ -41,7 +41,6 @@ import org.apache.hadoop.hbase.regionserver.DefaultStoreEngine; 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.regionserver.Region; import org.apache.hadoop.hbase.regionserver.StoreEngine; import org.apache.hadoop.hbase.regionserver.StripeStoreConfig; import org.apache.hadoop.hbase.regionserver.StripeStoreEngine; @@ -73,8 +72,8 @@ public class TestCompactionWithThroughputController { List rsts = cluster.getRegionServerThreads(); for (int i = 0; i < cluster.getRegionServerThreads().size(); i++) { HRegionServer hrs = rsts.get(i).getRegionServer(); - for (Region region : hrs.getRegions(tableName)) { - return ((HRegion) region).getStores().iterator().next(); + for (HRegion region : hrs.getRegions(tableName)) { + return region.getStores().iterator().next(); } } return null; diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestFlushWithThroughputController.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestFlushWithThroughputController.java index ca6c86b..c4e2195 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestFlushWithThroughputController.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/throttle/TestFlushWithThroughputController.java @@ -35,7 +35,6 @@ import org.apache.hadoop.hbase.regionserver.DefaultStoreEngine; 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.regionserver.Region; import org.apache.hadoop.hbase.regionserver.StoreEngine; import org.apache.hadoop.hbase.regionserver.StripeStoreEngine; import org.apache.hadoop.hbase.testclassification.MediumTests; @@ -79,8 +78,8 @@ public class TestFlushWithThroughputController { List rsts = cluster.getRegionServerThreads(); for (int i = 0; i < cluster.getRegionServerThreads().size(); i++) { HRegionServer hrs = rsts.get(i).getRegionServer(); - for (Region region : hrs.getRegions(tableName)) { - return ((HRegion) region).getStores().iterator().next(); + for (HRegion region : hrs.getRegions(tableName)) { + return region.getStores().iterator().next(); } } return null; @@ -165,7 +164,7 @@ public class TestFlushWithThroughputController { HRegionServer regionServer = hbtu.getRSForFirstRegionInTable(tableName); PressureAwareFlushThroughputController throughputController = (PressureAwareFlushThroughputController) regionServer.getFlushThroughputController(); - for (Region region : regionServer.getRegions()) { + for (HRegion region : regionServer.getRegions()) { region.flush(true); } assertEquals(0.0, regionServer.getFlushPressure(), EPSILON); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestLogRolling.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestLogRolling.java index 4c3d2a5..c04720b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestLogRolling.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/AbstractTestLogRolling.java @@ -40,8 +40,8 @@ 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.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HRegionServer; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.Store; import org.apache.hadoop.hbase.util.Bytes; import org.apache.hadoop.hbase.util.Threads; @@ -196,7 +196,7 @@ public abstract class AbstractTestLogRolling { assertLogFileSize(log); // flush all regions - for (Region r : server.getOnlineRegionsLocalContext()) { + for (HRegion r : server.getOnlineRegionsLocalContext()) { r.flush(true); } @@ -249,7 +249,7 @@ public abstract class AbstractTestLogRolling { table = createTestTable(getName()); server = TEST_UTIL.getRSForFirstRegionInTable(table.getName()); - Region region = server.getRegions(table.getName()).get(0); + HRegion region = server.getRegions(table.getName()).get(0); final WAL log = server.getWAL(region.getRegionInfo()); Store s = region.getStore(HConstants.CATALOG_FAMILY); 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 0598e34..3abc94a 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 @@ -80,10 +80,8 @@ import org.apache.hadoop.hbase.regionserver.HStore; import org.apache.hadoop.hbase.regionserver.MemStoreSnapshot; import org.apache.hadoop.hbase.regionserver.MemstoreSize; import org.apache.hadoop.hbase.regionserver.MultiVersionConcurrencyControl; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.regionserver.RegionScanner; import org.apache.hadoop.hbase.regionserver.RegionServerServices; -import org.apache.hadoop.hbase.regionserver.Store; import org.apache.hadoop.hbase.regionserver.throttle.ThroughputController; import org.apache.hadoop.hbase.security.User; import org.apache.hadoop.hbase.util.Bytes; @@ -217,7 +215,7 @@ public abstract class AbstractTestWALReplay { assertEquals(1, regions.size()); // move region to another regionserver - Region destRegion = regions.get(0); + HRegion destRegion = regions.get(0); int originServerNum = hbaseCluster.getServerWith(destRegion.getRegionInfo().getRegionName()); assertTrue("Please start more than 1 regionserver", hbaseCluster.getRegionServerThreads().size() > 1); @@ -242,8 +240,7 @@ public abstract class AbstractTestWALReplay { assertEquals(0, count); // flush region and make major compaction - HRegion region = - (HRegion) destServer.getOnlineRegion(destRegion.getRegionInfo().getRegionName()); + HRegion region = destServer.getOnlineRegion(destRegion.getRegionInfo().getRegionName()); region.flush(true); // wait to complete major compaction for (HStore store : region.getStores()) { @@ -283,7 +280,7 @@ public abstract class AbstractTestWALReplay { deleteDir(basedir); HTableDescriptor htd = createBasic3FamilyHTD(tableName); - Region region2 = HBaseTestingUtility.createRegionAndWAL(hri, hbaseRootDir, this.conf, htd); + HRegion region2 = HBaseTestingUtility.createRegionAndWAL(hri, hbaseRootDir, this.conf, htd); HBaseTestingUtility.closeRegionAndWAL(region2); final byte [] rowName = tableName.getName(); @@ -348,10 +345,10 @@ public abstract class AbstractTestWALReplay { final Path basedir = new Path(this.hbaseRootDir, tableName.getNameAsString()); deleteDir(basedir); final HTableDescriptor htd = createBasic3FamilyHTD(tableName); - Region region2 = HBaseTestingUtility.createRegionAndWAL(hri, hbaseRootDir, this.conf, htd); + HRegion region2 = HBaseTestingUtility.createRegionAndWAL(hri, hbaseRootDir, this.conf, htd); HBaseTestingUtility.closeRegionAndWAL(region2); WAL wal = createWAL(this.conf, hbaseRootDir, logName); - Region region = HRegion.openHRegion(hri, htd, wal, this.conf); + HRegion region = HRegion.openHRegion(hri, htd, wal, this.conf); byte [] family = htd.getFamilies().iterator().next().getName(); Path f = new Path(basedir, "hfile"); @@ -1118,7 +1115,7 @@ public abstract class AbstractTestWALReplay { private HRegion r; @Override - public void requestFlush(Region region, boolean force) { + public void requestFlush(HRegion region, boolean force) { try { r.flush(force); } catch (IOException e) { @@ -1127,8 +1124,7 @@ public abstract class AbstractTestWALReplay { } @Override - public void requestDelayedFlush(Region region, long when, boolean forceFlushAllStores) { - // TODO Auto-generated method stub + public void requestDelayedFlush(HRegion region, long when, boolean forceFlushAllStores) { } @@ -1184,7 +1180,7 @@ public abstract class AbstractTestWALReplay { } static List addRegionEdits(final byte[] rowName, final byte[] family, final int count, - EnvironmentEdge ee, final Region r, final String qualifierPrefix) throws IOException { + EnvironmentEdge ee, final HRegion r, final String qualifierPrefix) throws IOException { List puts = new ArrayList<>(); for (int j = 0; j < count; j++) { byte[] qualifier = Bytes.toBytes(qualifierPrefix + Integer.toString(j)); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java index 1585e79..9b9780a 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestFSHLog.java @@ -183,7 +183,7 @@ public class TestFSHLog extends AbstractTestFSWAL { @Override public void run() { try { - Region.FlushResult flushResult = region.flush(true); + HRegion.FlushResult flushResult = region.flush(true); LOG.info("Flush result:" + flushResult.getResult()); LOG.info("Flush succeeded:" + flushResult.isFlushSucceeded()); flushFinished.countDown(); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestLogRolling.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestLogRolling.java index de6fdb3..c6a7792 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestLogRolling.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/regionserver/wal/TestLogRolling.java @@ -47,7 +47,7 @@ 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.fs.HFileSystem; -import org.apache.hadoop.hbase.regionserver.Region; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.testclassification.LargeTests; import org.apache.hadoop.hbase.testclassification.VerySlowRegionServerTests; import org.apache.hadoop.hbase.util.Bytes; @@ -345,7 +345,7 @@ public class TestLogRolling extends AbstractTestLogRolling { assertTrue(loggedRows.contains("row1005")); // flush all regions - for (Region r : server.getOnlineRegionsLocalContext()) { + for (HRegion r : server.getOnlineRegionsLocalContext()) { try { r.flush(true); } catch (Exception e) { diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/regionserver/TestRegionReplicaReplicationEndpoint.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/regionserver/TestRegionReplicaReplicationEndpoint.java index 8068130..910449b 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/regionserver/TestRegionReplicaReplicationEndpoint.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/replication/regionserver/TestRegionReplicaReplicationEndpoint.java @@ -44,6 +44,7 @@ import org.apache.hadoop.hbase.client.RegionLocator; import org.apache.hadoop.hbase.client.RpcRetryingCallerImpl; import org.apache.hadoop.hbase.client.Table; import org.apache.hadoop.hbase.client.replication.ReplicationAdmin; +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.wal.WAL.Entry; @@ -247,8 +248,8 @@ public class TestRegionReplicaReplicationEndpoint { for (int i=0; i < NB_SERVERS; i++) { HRegionServer rs = HTU.getMiniHBaseCluster().getRegionServer(i); - List onlineRegions = rs.getRegions(tableName); - for (Region region : onlineRegions) { + List onlineRegions = rs.getRegions(tableName); + for (HRegion region : onlineRegions) { regions[region.getRegionInfo().getReplicaId()] = region; } } diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/visibility/TestVisibilityLabels.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/visibility/TestVisibilityLabels.java index 29bce1a..8cc2fd0 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/security/visibility/TestVisibilityLabels.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/security/visibility/TestVisibilityLabels.java @@ -307,8 +307,7 @@ public abstract class TestVisibilityLabels { List regionServerThreads = TEST_UTIL.getHBaseCluster() .getRegionServerThreads(); for (RegionServerThread rsThread : regionServerThreads) { - List onlineRegions = rsThread.getRegionServer().getRegions( - LABELS_TABLE_NAME); + List onlineRegions = rsThread.getRegionServer().getRegions(LABELS_TABLE_NAME); if (onlineRegions.size() > 0) { rsThread.getRegionServer().abort("Aborting "); killedRS = true; @@ -341,8 +340,7 @@ public abstract class TestVisibilityLabels { for (RegionServerThread rsThread : regionServerThreads) { while (true) { if (!rsThread.getRegionServer().isAborted()) { - List onlineRegions = rsThread.getRegionServer().getRegions( - LABELS_TABLE_NAME); + List onlineRegions = rsThread.getRegionServer().getRegions(LABELS_TABLE_NAME); if (onlineRegions.size() > 0) { break; } else { @@ -398,7 +396,7 @@ public abstract class TestVisibilityLabels { } catch (InterruptedException e) { } } - Region labelsTableRegion = regionServer.getRegions(LABELS_TABLE_NAME).get(0); + HRegion labelsTableRegion = regionServer.getRegions(LABELS_TABLE_NAME).get(0); while (labelsTableRegion.isRecovering()) { try { Thread.sleep(10); diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/SnapshotTestingUtils.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/SnapshotTestingUtils.java index 3f0b5b4..8d13f3e 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/SnapshotTestingUtils.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/snapshot/SnapshotTestingUtils.java @@ -61,9 +61,9 @@ import org.apache.hadoop.hbase.io.HFileLink; import org.apache.hadoop.hbase.master.HMaster; import org.apache.hadoop.hbase.master.MasterFileSystem; import org.apache.hadoop.hbase.mob.MobUtils; +import org.apache.hadoop.hbase.regionserver.HRegion; import org.apache.hadoop.hbase.regionserver.HRegionFileSystem; import org.apache.hadoop.hbase.regionserver.HRegionServer; -import org.apache.hadoop.hbase.regionserver.Region; import org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos; import org.apache.hadoop.hbase.shaded.protobuf.generated.SnapshotProtos.SnapshotRegionManifest; @@ -754,8 +754,8 @@ public final class SnapshotTestingUtils { final TableName tableName) throws IOException, InterruptedException { HRegionServer rs = util.getRSForFirstRegionInTable(tableName); - List onlineRegions = rs.getRegions(tableName); - for (Region region : onlineRegions) { + List onlineRegions = rs.getRegions(tableName); + for (HRegion region : onlineRegions) { region.waitForFlushesAndCompactions(); } // Wait up to 60 seconds for a table to be available. diff --git a/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsckEncryption.java b/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsckEncryption.java index 641f66e..348734d 100644 --- a/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsckEncryption.java +++ b/hbase-server/src/test/java/org/apache/hadoop/hbase/util/TestHBaseFsckEncryption.java @@ -141,9 +141,9 @@ public class TestHBaseFsckEncryption { private List findStorefilePaths(TableName tableName) throws Exception { List paths = new ArrayList<>(); - for (Region region : TEST_UTIL.getRSForFirstRegionInTable(tableName) + for (HRegion region : TEST_UTIL.getRSForFirstRegionInTable(tableName) .getRegions(htd.getTableName())) { - for (HStore store : ((HRegion) region).getStores()) { + for (HStore store : region.getStores()) { for (HStoreFile storefile : store.getStorefiles()) { paths.add(storefile.getPath()); }