org.apache.hadoop.hbase.quotas.ThrottlingException Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of phoenix-client
Phoenix Client
There is a newer version: 4.15.0-HBase-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 regarding
 * copyright ownership. The ASF licenses this file to you under the Apache License, Version 2.0 (the
 * "License"); you may not use this file except in compliance with the License. You may obtain a
 * copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable
 * law or agreed to in writing, software distributed under the License is distributed on an "AS IS"
 * BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License
 * for the specific language governing permissions and limitations under the License.
 */

package org.apache.hadoop.hbase.quotas;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

import org.apache.hadoop.hbase.classification.InterfaceAudience;
import org.apache.hadoop.hbase.classification.InterfaceStability;

/**
 * Describe the throttling result. TODO: At some point this will be handled on the client side to
 * prevent operation to go on the server if the waitInterval is grater than the one got as result of
 * this exception.
 */
@InterfaceAudience.Public
@InterfaceStability.Evolving
public class ThrottlingException extends QuotaExceededException {
  private static final long serialVersionUID = 1406576492085155743L;

  @InterfaceAudience.Public
  @InterfaceStability.Evolving
  public enum Type {
    NumRequestsExceeded, RequestSizeExceeded, NumReadRequestsExceeded, NumWriteRequestsExceeded,
    WriteSizeExceeded, ReadSizeExceeded,
  }

  private static final String[] MSG_TYPE =
      new String[] { "number of requests exceeded", "request size limit exceeded",
          "number of read requests exceeded", "number of write requests exceeded",
          "write size limit exceeded", "read size limit exceeded", };

  private static final String MSG_WAIT = " - wait ";

  private long waitInterval;
  private Type type;

  public ThrottlingException(String msg) {
    super(msg);

    // Dirty workaround to get the information after
    // ((RemoteException)e.getCause()).unwrapRemoteException()
    for (int i = 0; i < MSG_TYPE.length; ++i) {
      int index = msg.indexOf(MSG_TYPE[i]);
      if (index >= 0) {
        String waitTimeStr = msg.substring(index + MSG_TYPE[i].length() + MSG_WAIT.length());
        type = Type.values()[i];
        waitInterval = timeFromString(waitTimeStr);
        break;
      }
    }
  }

  public ThrottlingException(final Type type, final long waitInterval, final String msg) {
    super(msg);
    this.waitInterval = waitInterval;
    this.type = type;
  }

  public Type getType() {
    return this.type;
  }

  public long getWaitInterval() {
    return this.waitInterval;
  }

  public static void throwNumRequestsExceeded(final long waitInterval) throws ThrottlingException {
    throwThrottlingException(Type.NumRequestsExceeded, waitInterval);
  }
  
  public static void throwRequestSizeExceeded(final long waitInterval)
      throws ThrottlingException {
    throwThrottlingException(Type.RequestSizeExceeded, waitInterval);
  }

  public static void throwNumReadRequestsExceeded(final long waitInterval)
      throws ThrottlingException {
    throwThrottlingException(Type.NumReadRequestsExceeded, waitInterval);
  }

  public static void throwNumWriteRequestsExceeded(final long waitInterval)
      throws ThrottlingException {
    throwThrottlingException(Type.NumWriteRequestsExceeded, waitInterval);
  }

  public static void throwWriteSizeExceeded(final long waitInterval) throws ThrottlingException {
    throwThrottlingException(Type.WriteSizeExceeded, waitInterval);
  }

  public static void throwReadSizeExceeded(final long waitInterval) throws ThrottlingException {
    throwThrottlingException(Type.ReadSizeExceeded, waitInterval);
  }

  private static void throwThrottlingException(final Type type, final long waitInterval)
      throws ThrottlingException {
    String msg = MSG_TYPE[type.ordinal()] + MSG_WAIT + formatTime(waitInterval);
    throw new ThrottlingException(type, waitInterval, msg);
  }

  public static String formatTime(long timeDiff) {
    StringBuilder buf = new StringBuilder();
    long hours = timeDiff / (60 * 60 * 1000);
    long rem = (timeDiff % (60 * 60 * 1000));
    long minutes = rem / (60 * 1000);
    rem = rem % (60 * 1000);
    float seconds = rem / 1000.0f;

    if (hours != 0) {
      buf.append(hours);
      buf.append("hrs, ");
    }
    if (minutes != 0) {
      buf.append(minutes);
      buf.append("mins, ");
    }
    buf.append(String.format("%.2fsec", seconds));
    return buf.toString();
  }

  private static long timeFromString(String timeDiff) {
    Pattern[] patterns =
        new Pattern[] { Pattern.compile("^(\\d+\\.\\d\\d)sec"),
            Pattern.compile("^(\\d+)mins, (\\d+\\.\\d\\d)sec"),
            Pattern.compile("^(\\d+)hrs, (\\d+)mins, (\\d+\\.\\d\\d)sec") };

    for (int i = 0; i < patterns.length; ++i) {
      Matcher m = patterns[i].matcher(timeDiff);
      if (m.find()) {
        long time = Math.round(Float.parseFloat(m.group(1 + i)) * 1000);
        if (i > 0) {
          time += Long.parseLong(m.group(i)) * (60 * 1000);
        }
        if (i > 1) {
          time += Long.parseLong(m.group(i - 1)) * (60 * 60 * 1000);
        }
        return time;
      }
    }

    return -1;
  }
}