Java ExceptionUtil.isInterrupt方法代码示例

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
/**
 *  Handle connection failures
 *
 * If the current number of retries is equal to the max number of retries,
 * stop retrying and throw the exception; Otherwise backoff N seconds and
 * try connecting again.
 *
 * This Method is only called from inside setupIOstreams(), which is
 * synchronized. Hence the sleep is synchronized; the locks will be retained.
 *
 * @param curRetries current number of retries
 * @param maxRetries max number of retries allowed
 * @param ioe failure reason
 * @throws IOException if max number of retries is reached
 */
private void handleConnectionFailure(int curRetries, int maxRetries, IOException ioe)
throws IOException {
  closeConnection();

  // throw the exception if the maximum number of retries is reached
  if (curRetries >= maxRetries || ExceptionUtil.isInterrupt(ioe)) {
    throw ioe;
  }

  // otherwise back off and retry
  try {
    Thread.sleep(failureSleep);
  } catch (InterruptedException ie) {
    ExceptionUtil.rethrowIfInterrupt(ie);
  }

  LOG.info("Retrying connect to server: " + remoteId.getAddress() +
    " after sleeping " + failureSleep + "ms. Already tried " + curRetries +
    " time(s).");
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
/**
 * Handle connection failures If the current number of retries is equal to the max number of
 * retries, stop retrying and throw the exception; Otherwise backoff N seconds and try connecting
 * again. This Method is only called from inside setupIOstreams(), which is synchronized. Hence
 * the sleep is synchronized; the locks will be retained.
 * @param curRetries current number of retries
 * @param maxRetries max number of retries allowed
 * @param ioe failure reason
 * @throws IOException if max number of retries is reached
 */
private void handleConnectionFailure(int curRetries, int maxRetries, IOException ioe)
    throws IOException {
  closeSocket();

  // throw the exception if the maximum number of retries is reached
  if (curRetries >= maxRetries || ExceptionUtil.isInterrupt(ioe)) {
    throw ioe;
  }

  // otherwise back off and retry
  try {
    Thread.sleep(this.rpcClient.failureSleep);
  } catch (InterruptedException ie) {
    ExceptionUtil.rethrowIfInterrupt(ie);
  }

  if (LOG.isInfoEnabled()) {
    LOG.info("Retrying connect to server: " + remoteId.getAddress() +
      " after sleeping " + this.rpcClient.failureSleep + "ms. Already tried " + curRetries +
      " time(s).");
  }
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
@Override
public void run() {
  try {
    LOG.info("SplitLogWorker " + server.getServerName() + " starting");
    coordination.registerListener();
    // wait for Coordination Engine is ready
    boolean res = false;
    while (!res && !coordination.isStop()) {
      res = coordination.isReady();
    }
    if (!coordination.isStop()) {
      coordination.taskLoop();
    }
  } catch (Throwable t) {
    if (ExceptionUtil.isInterrupt(t)) {
      LOG.info("SplitLogWorker interrupted. Exiting. " + (coordination.isStop() ? "" :
          " (ERROR: exitWorker is not set, exiting anyway)"));
    } else {
      // only a logical error can cause here. Printing it out
      // to make debugging easier
      LOG.error("unexpected error ", t);
    }
  } finally {
    coordination.removeListener();
    LOG.info("SplitLogWorker " + server.getServerName() + " exiting");
  }
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
/**
 * Return the IOException thrown by the remote server wrapped in
 * ServiceException as cause.
 *
 * @param se ServiceException that wraps IO exception thrown by the server
 * @return Exception wrapped in ServiceException or
 *   a new IOException that wraps the unexpected ServiceException.
 */
public static IOException getRemoteException(ServiceException se) {
  Throwable e = se.getCause();
  if (e == null) {
    return new IOException(se);
  }
  if (ExceptionUtil.isInterrupt(e)) {
    return ExceptionUtil.asInterrupt(e);
  }
  if (e instanceof RemoteException) {
    e = ((RemoteException) e).unwrapRemoteException();
  }
  return e instanceof IOException ? (IOException) e : new IOException(se);
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
/**
 * Set failed
 *
 * @param exception to set
 */
public void setFailed(IOException exception) {
  if (ExceptionUtil.isInterrupt(exception)) {
    exception = ExceptionUtil.asInterrupt(exception);
  }
  if (exception instanceof RemoteException) {
    exception = ((RemoteException) exception).unwrapRemoteException();
  }

  this.setFailure(exception);
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
/**
 * Return the Exception thrown by the remote server wrapped in
 * ServiceException as cause. RemoteException are left untouched.
 *
 * @param e ServiceException that wraps IO exception thrown by the server
 * @return Exception wrapped in ServiceException.
 */
public static IOException getServiceException(org.apache.hbase.thirdparty.com.google.protobuf.ServiceException e) {
  Throwable t = e.getCause();
  if (ExceptionUtil.isInterrupt(t)) {
    return ExceptionUtil.asInterrupt(t);
  }
  return t instanceof IOException ? (IOException) t : new HBaseIOException(t);
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
private static IOException makeIOExceptionOfException(Exception e) {
  Throwable t = e;
  if (e instanceof ServiceException ||
      e instanceof org.apache.hbase.thirdparty.com.google.protobuf.ServiceException) {
    t = e.getCause();
  }
  if (ExceptionUtil.isInterrupt(t)) {
    return ExceptionUtil.asInterrupt(t);
  }
  if (t instanceof RemoteException) {
    t = ((RemoteException)t).unwrapRemoteException();
  }
  return t instanceof IOException? (IOException)t: new HBaseIOException(t);
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
private static IOException makeIOExceptionOfException(Exception e) {
  Throwable t = e;
  if (e instanceof ServiceException) {
    t = e.getCause();
  }
  if (ExceptionUtil.isInterrupt(t)) {
    return ExceptionUtil.asInterrupt(t);
  }
  if (t instanceof RemoteException) {
    t = ((RemoteException)t).unwrapRemoteException();
  }
  return t instanceof IOException? (IOException)t: new HBaseIOException(t);
}
 

import org.apache.hadoop.hbase.util.ExceptionUtil; //导入方法依赖的package包/类
@Override
public void run() {
  try {
    LOG.info("SplitLogWorker " + this.serverName + " starting");
    this.watcher.registerListener(this);
    boolean distributedLogReplay = HLogSplitter.isDistributedLogReplay(conf);
    if (distributedLogReplay) {
      // initialize a new connection for splitlogworker configuration
      HConnectionManager.getConnection(conf);
    }

    // wait for master to create the splitLogZnode
    int res = -1;
    while (res == -1 && !exitWorker) {
      try {
        res = ZKUtil.checkExists(watcher, watcher.splitLogZNode);
      } catch (KeeperException e) {
        // ignore
        LOG.warn("Exception when checking for " + watcher.splitLogZNode  + " ... retrying", e);
      }
      if (res == -1) {
        LOG.info(watcher.splitLogZNode + " znode does not exist, waiting for master to create");
        Thread.sleep(1000);
      }
    }

    if (!exitWorker) {
        taskLoop();
    }
  } catch (Throwable t) {
    if (ExceptionUtil.isInterrupt(t)) {
      LOG.info("SplitLogWorker interrupted. Exiting. " + (exitWorker ? "" :
          " (ERROR: exitWorker is not set, exiting anyway)"));
    } else {
      // only a logical error can cause here. Printing it out
      // to make debugging easier
      LOG.error("unexpected error ", t);
    }
  } finally {
    LOG.info("SplitLogWorker " + this.serverName + " exiting");
  }
}