hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RegionServerServices.java

   1 /**
   2  *
   3  * Licensed to the Apache Software Foundation (ASF) under one
   4  * or more contributor license agreements.  See the NOTICE file
   5  * distributed with this work for additional information
   6  * regarding copyright ownership.  The ASF licenses this file
   7  * to you under the Apache License, Version 2.0 (the
   8  * "License"); you may not use this file except in compliance
   9  * with the License.  You may obtain a copy of the License at
  10  *
  11  *     http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  */
  19 package org.apache.hadoop.hbase.regionserver;
  20
  21 import java.io.IOException;
  22 import java.util.Collection;
  23 import java.util.List;
  24 import java.util.Map.Entry;
  25 import java.util.Optional;
  26 import java.util.concurrent.ConcurrentMap;
  27 import org.apache.hadoop.hbase.Abortable;
  28 import org.apache.hadoop.hbase.Server;
  29 import org.apache.hadoop.hbase.TableDescriptors;
  30 import org.apache.hadoop.hbase.TableName;
  31 import org.apache.hadoop.hbase.client.RegionInfo;
  32 import org.apache.hadoop.hbase.client.locking.EntityLock;
  33 import org.apache.hadoop.hbase.executor.ExecutorService;
  34 import org.apache.hadoop.hbase.io.hfile.BlockCache;
  35 import org.apache.hadoop.hbase.ipc.RpcServerInterface;
  36 import org.apache.hadoop.hbase.mob.MobFileCache;
  37 import org.apache.hadoop.hbase.quotas.RegionServerRpcQuotaManager;
  38 import org.apache.hadoop.hbase.quotas.RegionServerSpaceQuotaManager;
  39 import org.apache.hadoop.hbase.quotas.RegionSizeStore;
  40 import org.apache.hadoop.hbase.regionserver.compactions.CompactionRequester;
  41 import org.apache.hadoop.hbase.regionserver.regionreplication.RegionReplicationBufferManager;
  42 import org.apache.hadoop.hbase.regionserver.throttle.ThroughputController;
  43 import org.apache.hadoop.hbase.security.access.AccessChecker;
  44 import org.apache.hadoop.hbase.security.access.ZKPermissionWatcher;
  45 import org.apache.hadoop.hbase.wal.WAL;
  46 import org.apache.yetus.audience.InterfaceAudience;
  47
  48 import org.apache.hbase.thirdparty.com.google.protobuf.Service;
  49
  50 import org.apache.hadoop.hbase.shaded.protobuf.generated.RegionServerStatusProtos.RegionStateTransition.TransitionCode;
  51
  52 /**
  53  * A curated subset of services provided by {@link HRegionServer}.
  54  * For use internally only. Passed to Managers, Services and Chores so can pass less-than-a
  55  * full-on HRegionServer at test-time. Be judicious adding API. Changes cause ripples through
  56  * the code base.
  57  */
  58 @InterfaceAudience.Private
  59 public interface RegionServerServices extends Server, MutableOnlineRegions, FavoredNodesForRegion {
  60
  61   /** @return the WAL for a particular region. Pass null for getting the
  62    * default (common) WAL */
  63   WAL getWAL(RegionInfo regionInfo) throws IOException;
  64
  65   /** @return the List of WALs that are used by this server
  66    *  Doesn't include the meta WAL
  67    */
  68   List<WAL> getWALs() throws IOException;
  69
  70   /**
  71    * @return Implementation of {@link FlushRequester} or null. Usually it will not be null unless
  72    *         during intialization.
  73    */
  74   FlushRequester getFlushRequester();
  75
  76   /**
  77    * @return Implementation of {@link CompactionRequester} or null. Usually it will not be null
  78    *         unless during intialization.
  79    */
  80   CompactionRequester getCompactionRequestor();
  81
  82   /**
  83    * @return the RegionServerAccounting for this Region Server
  84    */
  85   RegionServerAccounting getRegionServerAccounting();
  86
  87   /**
  88    * @return RegionServer's instance of {@link RegionServerRpcQuotaManager}
  89    */
  90   RegionServerRpcQuotaManager getRegionServerRpcQuotaManager();
  91
  92   /**
  93    * @return RegionServer's instance of {@link SecureBulkLoadManager}
  94    */
  95   SecureBulkLoadManager getSecureBulkLoadManager();
  96
  97   /**
  98    * @return RegionServer's instance of {@link RegionServerSpaceQuotaManager}
  99    */
 100   RegionServerSpaceQuotaManager getRegionServerSpaceQuotaManager();
 101
 102   /**
 103    * Context for postOpenDeployTasks().
 104    */
 105   class PostOpenDeployContext {
 106     private final HRegion region;
 107     private final long openProcId;
 108     private final long masterSystemTime;
 109
 110     public PostOpenDeployContext(HRegion region, long openProcId, long masterSystemTime) {
 111       this.region = region;
 112       this.openProcId = openProcId;
 113       this.masterSystemTime = masterSystemTime;
 114     }
 115
 116     public HRegion getRegion() {
 117       return region;
 118     }
 119
 120     public long getOpenProcId() {
 121       return openProcId;
 122     }
 123
 124     public long getMasterSystemTime() {
 125       return masterSystemTime;
 126     }
 127   }
 128
 129   /**
 130    * Tasks to perform after region open to complete deploy of region on regionserver
 131    * @param context the context
 132    */
 133   void postOpenDeployTasks(final PostOpenDeployContext context) throws IOException;
 134
 135   class RegionStateTransitionContext {
 136     private final TransitionCode code;
 137     private final long openSeqNum;
 138     private final long masterSystemTime;
 139     private final long[] procIds;
 140     private final RegionInfo[] hris;
 141
 142     public RegionStateTransitionContext(TransitionCode code, long openSeqNum, long masterSystemTime,
 143         RegionInfo... hris) {
 144       this.code = code;
 145       this.openSeqNum = openSeqNum;
 146       this.masterSystemTime = masterSystemTime;
 147       this.hris = hris;
 148       this.procIds = new long[hris.length];
 149     }
 150
 151     public RegionStateTransitionContext(TransitionCode code, long openSeqNum, long procId,
 152         long masterSystemTime, RegionInfo hri) {
 153       this.code = code;
 154       this.openSeqNum = openSeqNum;
 155       this.masterSystemTime = masterSystemTime;
 156       this.hris = new RegionInfo[] { hri };
 157       this.procIds = new long[] { procId };
 158     }
 159
 160     public TransitionCode getCode() {
 161       return code;
 162     }
 163
 164     public long getOpenSeqNum() {
 165       return openSeqNum;
 166     }
 167
 168     public long getMasterSystemTime() {
 169       return masterSystemTime;
 170     }
 171
 172     public RegionInfo[] getHris() {
 173       return hris;
 174     }
 175
 176     public long[] getProcIds() {
 177       return procIds;
 178     }
 179   }
 180
 181   /**
 182    * Notify master that a handler requests to change a region state
 183    */
 184   boolean reportRegionStateTransition(final RegionStateTransitionContext context);
 185
 186   /**
 187    * Returns a reference to the region server's RPC server
 188    */
 189   RpcServerInterface getRpcServer();
 190
 191   /**
 192    * Get the regions that are currently being opened or closed in the RS
 193    * @return map of regions in transition in this RS
 194    */
 195   ConcurrentMap<byte[], Boolean> getRegionsInTransitionInRS();
 196
 197   /**
 198    * @return The RegionServer's "Leases" service
 199    */
 200   LeaseManager getLeaseManager();
 201
 202   /**
 203    * @return hbase executor service
 204    */
 205   ExecutorService getExecutorService();
 206
 207   /**
 208    * Only required for "old" log replay; if it's removed, remove this.
 209    * @return The RegionServer's NonceManager
 210    */
 211   ServerNonceManager getNonceManager();
 212
 213   /**
 214    * Registers a new protocol buffer {@link Service} subclass as a coprocessor endpoint to be
 215    * available for handling
 216    * @param service the {@code Service} subclass instance to expose as a coprocessor endpoint
 217    * @return {@code true} if the registration was successful, {@code false}
 218    */
 219   boolean registerService(Service service);
 220
 221   /**
 222    * @return heap memory manager instance
 223    */
 224   HeapMemoryManager getHeapMemoryManager();
 225
 226   /**
 227    * @return the max compaction pressure of all stores on this regionserver. The value should be
 228    *         greater than or equal to 0.0, and any value greater than 1.0 means we enter the
 229    *         emergency state that some stores have too many store files.
 230    * @see org.apache.hadoop.hbase.regionserver.Store#getCompactionPressure()
 231    */
 232   double getCompactionPressure();
 233
 234   /**
 235    * @return the controller to avoid flush too fast
 236    */
 237   ThroughputController getFlushThroughputController();
 238
 239   /**
 240    * @return the flush pressure of all stores on this regionserver. The value should be greater than
 241    *         or equal to 0.0, and any value greater than 1.0 means we enter the emergency state that
 242    *         global memstore size already exceeds lower limit.
 243    */
 244   @Deprecated
 245   double getFlushPressure();
 246
 247   /**
 248    * @return the metrics tracker for the region server
 249    */
 250   MetricsRegionServer getMetrics();
 251
 252   /**
 253    * Master based locks on namespaces/tables/regions.
 254    */
 255   EntityLock regionLock(List<RegionInfo> regionInfos, String description,
 256       Abortable abort) throws IOException;
 257
 258   /**
 259    * Unassign the given region from the current regionserver and assign it randomly. Could still be
 260    * assigned to us. This is used to solve some tough problems for which you need to reset the state
 261    * of a region. For example, if you hit FileNotFound exception and want to refresh the store file
 262    * list.
 263    * <p>
 264    * See HBASE-17712 for more details.
 265    */
 266   void unassign(byte[] regionName) throws IOException;
 267
 268   /**
 269    * Reports the provided Region sizes hosted by this RegionServer to the active Master.
 270    *
 271    * @param sizeStore The sizes for Regions locally hosted.
 272    * @return {@code false} if reporting should be temporarily paused, {@code true} otherwise.
 273    */
 274   boolean reportRegionSizesForQuotas(RegionSizeStore sizeStore);
 275
 276   /**
 277    * Reports a collection of files, and their sizes, that belonged to the given {@code table} were
 278    * just moved to the archive directory.
 279    *
 280    * @param tableName The name of the table that files previously belonged to
 281    * @param archivedFiles Files and their sizes that were moved to archive
 282    * @return {@code true} if the files were successfully reported, {@code false} otherwise.
 283    */
 284   boolean reportFileArchivalForQuotas(
 285       TableName tableName, Collection<Entry<String,Long>> archivedFiles);
 286
 287   /**
 288    * @return True if cluster is up; false if cluster is not up (we are shutting down).
 289    */
 290   boolean isClusterUp();
 291
 292   /**
 293    * @return Return the object that implements the replication source executorService.
 294    */
 295   ReplicationSourceService getReplicationSourceService();
 296
 297   /**
 298    * @return Return table descriptors implementation.
 299    */
 300   TableDescriptors getTableDescriptors();
 301
 302   /**
 303    * @return The block cache instance.
 304    */
 305   Optional<BlockCache> getBlockCache();
 306
 307   /**
 308    * @return The cache for mob files.
 309    */
 310   Optional<MobFileCache> getMobFileCache();
 311
 312   /**
 313    * @return the {@link AccessChecker}
 314    */
 315   AccessChecker getAccessChecker();
 316
 317   /**
 318    * @return {@link ZKPermissionWatcher}
 319    */
 320   ZKPermissionWatcher getZKPermissionWatcher();
 321
 322   RegionReplicationBufferManager getRegionReplicationBufferManager();
 323
 324   @Override
 325   HRegion getRegion(String encodedRegionName);
 326
 327   @Override
 328   List<HRegion> getRegions(TableName tableName) throws IOException;
 329
 330   @Override
 331   List<HRegion> getRegions();
 332 }