hbase-client/src/main/java/org/apache/hadoop/hbase/quotas/RpcThrottlingException.java

   1 /**
   2  * Licensed to the Apache Software Foundation (ASF) under one or more contributor license
   3  * agreements. See the NOTICE file distributed with this work for additional information regarding
   4  * copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the
   5  * "License"); you may not use this file except in compliance with the License. You may obtain a
   6  * copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable
   7  * law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
   8  * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
   9  * for the specific language governing permissions and limitations under the License.
  10  */
  11
  12 package org.apache.hadoop.hbase.quotas;
  13
  14 import java.util.regex.Matcher;
  15 import java.util.regex.Pattern;
  16 import org.apache.hadoop.hbase.HBaseIOException;
  17 import org.apache.hadoop.util.StringUtils;
  18
  19 import org.apache.yetus.audience.InterfaceAudience;
  20
  21 /**
  22  * Describe the throttling result. TODO: At some point this will be handled on the client side to
  23  * prevent operation to go on the server if the waitInterval is greater than the one got as result
  24  * of this exception.
  25  */
  26 @InterfaceAudience.Public
  27 public class RpcThrottlingException extends HBaseIOException {
  28
  29   @InterfaceAudience.Public
  30   public enum Type {
  31     NumRequestsExceeded, RequestSizeExceeded, NumReadRequestsExceeded, NumWriteRequestsExceeded,
  32     WriteSizeExceeded, ReadSizeExceeded, RequestCapacityUnitExceeded, ReadCapacityUnitExceeded,
  33     WriteCapacityUnitExceeded
  34   }
  35
  36   private static final String[] MSG_TYPE =
  37       new String[] { "number of requests exceeded", "request size limit exceeded",
  38         "number of read requests exceeded", "number of write requests exceeded",
  39         "write size limit exceeded", "read size limit exceeded", "request capacity unit exceeded",
  40         "read capacity unit exceeded", "write capacity unit exceeded" };
  41
  42   private static final String MSG_WAIT = " - wait ";
  43
  44   private long waitInterval;
  45   private Type type;
  46
  47   public RpcThrottlingException(String msg) {
  48     super(msg);
  49
  50     // Dirty workaround to get the information after
  51     // ((RemoteException)e.getCause()).unwrapRemoteException()
  52     for (int i = 0; i < MSG_TYPE.length; ++i) {
  53       int index = msg.indexOf(MSG_TYPE[i]);
  54       if (index >= 0) {
  55         String waitTimeStr = msg.substring(index + MSG_TYPE[i].length() + MSG_WAIT.length());
  56         type = Type.values()[i];
  57         waitInterval = timeFromString(waitTimeStr);
  58         break;
  59       }
  60     }
  61   }
  62
  63   public RpcThrottlingException(final Type type, final long waitInterval, final String msg) {
  64     super(msg);
  65     this.waitInterval = waitInterval;
  66     this.type = type;
  67   }
  68
  69   public Type getType() {
  70     return this.type;
  71   }
  72
  73   public long getWaitInterval() {
  74     return this.waitInterval;
  75   }
  76
  77   public static void throwNumRequestsExceeded(final long waitInterval) throws
  78       RpcThrottlingException {
  79     throwThrottlingException(Type.NumRequestsExceeded, waitInterval);
  80   }
  81
  82   public static void throwRequestSizeExceeded(final long waitInterval)
  83       throws RpcThrottlingException {
  84     throwThrottlingException(Type.RequestSizeExceeded, waitInterval);
  85   }
  86
  87   public static void throwNumReadRequestsExceeded(final long waitInterval)
  88       throws RpcThrottlingException {
  89     throwThrottlingException(Type.NumReadRequestsExceeded, waitInterval);
  90   }
  91
  92   public static void throwNumWriteRequestsExceeded(final long waitInterval)
  93       throws RpcThrottlingException {
  94     throwThrottlingException(Type.NumWriteRequestsExceeded, waitInterval);
  95   }
  96
  97   public static void throwWriteSizeExceeded(final long waitInterval) throws RpcThrottlingException {
  98     throwThrottlingException(Type.WriteSizeExceeded, waitInterval);
  99   }
 100
 101   public static void throwReadSizeExceeded(final long waitInterval) throws RpcThrottlingException {
 102     throwThrottlingException(Type.ReadSizeExceeded, waitInterval);
 103   }
 104
 105   public static void throwRequestCapacityUnitExceeded(final long waitInterval)
 106       throws RpcThrottlingException {
 107     throwThrottlingException(Type.RequestCapacityUnitExceeded, waitInterval);
 108   }
 109
 110   public static void throwReadCapacityUnitExceeded(final long waitInterval)
 111       throws RpcThrottlingException {
 112     throwThrottlingException(Type.ReadCapacityUnitExceeded, waitInterval);
 113   }
 114
 115   public static void throwWriteCapacityUnitExceeded(final long waitInterval)
 116       throws RpcThrottlingException {
 117     throwThrottlingException(Type.WriteCapacityUnitExceeded, waitInterval);
 118   }
 119
 120   private static void throwThrottlingException(final Type type, final long waitInterval)
 121       throws RpcThrottlingException {
 122     String msg = MSG_TYPE[type.ordinal()] + MSG_WAIT + StringUtils.formatTime(waitInterval);
 123     throw new RpcThrottlingException(type, waitInterval, msg);
 124   }
 125
 126   private static long timeFromString(String timeDiff) {
 127     Pattern[] patterns =
 128         new Pattern[] { Pattern.compile("^(\\d+\\.\\d\\d)sec"),
 129             Pattern.compile("^(\\d+)mins, (\\d+\\.\\d\\d)sec"),
 130             Pattern.compile("^(\\d+)hrs, (\\d+)mins, (\\d+\\.\\d\\d)sec") };
 131
 132     for (int i = 0; i < patterns.length; ++i) {
 133       Matcher m = patterns[i].matcher(timeDiff);
 134       if (m.find()) {
 135         long time = Math.round(Float.parseFloat(m.group(1 + i)) * 1000);
 136         if (i > 0) {
 137           time += Long.parseLong(m.group(i)) * (60 * 1000);
 138         }
 139         if (i > 1) {
 140           time += Long.parseLong(m.group(i - 1)) * (60 * 60 * 1000);
 141         }
 142         return time;
 143       }
 144     }
 145
 146     return -1;
 147   }
 148 }