Java MonitoredTask.abort方法代码示例

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Initialize this region.
 *
 * @param reporter Tickle every so often if initialize is taking a while.
 * @return What the next sequence (edit) id should be.
 * @throws IOException e
 */
private long initialize(final CancelableProgressable reporter) throws IOException {
  MonitoredTask status = TaskMonitor.get().createStatus("Initializing region " + this);
  long nextSeqId = -1;
  try {
    nextSeqId = initializeRegionInternals(reporter, status);
    return nextSeqId;
  } finally {
    // nextSeqid will be -1 if the initialization fails.
    // At least it will be 0 otherwise.
    if (nextSeqId == -1) {
      status.abort("Exception during region " + getRegionInfo().getRegionNameAsString()
          + " initialization.");
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Initialize this region.
 * @param reporter Tickle every so often if initialize is taking a while.
 * @return What the next sequence (edit) id should be.
 * @throws IOException e
 */
public long initialize(final CancelableProgressable reporter) throws IOException {

  MonitoredTask status = TaskMonitor.get().createStatus("Initializing region " + this);

  long nextSeqId = -1;
  try {
    nextSeqId = initializeRegionInternals(reporter, status);
    return nextSeqId;
  } finally {
    // nextSeqid will be -1 if the initialization fails.
    // At least it will be 0 otherwise.
    if (nextSeqId == -1) {
      status
          .abort("Exception during region " + this.getRegionNameAsString() + " initialization.");
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Initialize this region.
 *
 * @param reporter Tickle every so often if initialize is taking a while.
 * @return What the next sequence (edit) id should be.
 * @throws IOException e
 */
private long initialize(final CancelableProgressable reporter) throws IOException {
    MonitoredTask status = TaskMonitor.get().createStatus("Initializing region " + this);
    long nextSeqId = -1;
    try {
        nextSeqId = initializeRegionInternals(reporter, status);
        return nextSeqId;
    } finally {
        // nextSeqid will be -1 if the initialization fails.
        // At least it will be 0 otherwise.
        if (nextSeqId == -1) {
            status
                    .abort("Exception during region " + this.getRegionNameAsString() + " initialization.");
        }
    }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Initialize this region.
 *
 * @param reporter Tickle every so often if initialize is taking a while.
 * @return What the next sequence (edit) id should be.
 * @throws IOException e
 */
private long initialize(final CancelableProgressable reporter) throws IOException {
  MonitoredTask status = TaskMonitor.get().createStatus("Initializing region " + this);
  long nextSeqId = -1;
  try {
    nextSeqId = initializeRegionInternals(reporter, status);
    return nextSeqId;
  } finally {
    // nextSeqid will be -1 if the initialization fails.
    // At least it will be 0 otherwise.
    if (nextSeqId == -1) {
      status
          .abort("Exception during region " + this.getRegionNameAsString() + " initialization.");
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Initialize this region.
 *
 * @param reporter Tickle every so often if initialize is taking a while.
 * @return What the next sequence (edit) id should be.
 * @throws IOException e
 */
public long initialize(final CancelableProgressable reporter)
    throws IOException {

  MonitoredTask status = TaskMonitor.get().createStatus(
      "Initializing region " + this);

  long nextSeqId = -1;
  try {
    nextSeqId = initializeRegionInternals(reporter, status);
    return nextSeqId;
  } finally {
    // nextSeqid will be -1 if the initialization fails.
    // At least it will be 0 otherwise.
    if (nextSeqId == -1) {
      status.abort("Exception during region " + this.getRegionNameAsString()
          + " initialization.");
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Initialize this region.
 *
 * @param reporter Tickle every so often if initialize is taking a while.
 * @return What the next sequence (edit) id should be.
 * @throws IOException e
 */
private long initialize(final CancelableProgressable reporter) throws IOException {

  //Refuse to open the region if there is no column family in the table
  if (htableDescriptor.getColumnFamilyCount() == 0) {
    throw new DoNotRetryIOException("Table " + htableDescriptor.getTableName().getNameAsString()+
        " should have at least one column family.");
  }

  MonitoredTask status = TaskMonitor.get().createStatus("Initializing region " + this);
  long nextSeqId = -1;
  try {
    nextSeqId = initializeRegionInternals(reporter, status);
    return nextSeqId;
  } finally {
    // nextSeqid will be -1 if the initialization fails.
    // At least it will be 0 otherwise.
    if (nextSeqId == -1) {
      status.abort("Exception during region " + getRegionInfo().getRegionNameAsString() +
        " initialization.");
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Flush the cache. When this method is called the cache will be flushed unless:
 * <ol>
 * <li>the cache is empty</li>
 * <li>the region is closed.</li>
 * <li>a flush is already in progress</li>
 * <li>writes are disabled</li>
 * </ol>
 * <p>
 * This method may block for some time, so it should not be called from a time-sensitive thread.
 * @return true if the region needs compaction
 * @throws IOException general io exceptions
 * @throws DroppedSnapshotException Thrown when replay of hlog is required because a Snapshot was
 *           not properly persisted.
 */
public boolean flushcache() throws IOException {
  // fail-fast instead of waiting on the lock
  if (this.closing.get()) {
    LOG.debug("Skipping flush on " + this + " because closing");
    return false;
  }
  MonitoredTask status = TaskMonitor.get().createStatus("Flushing " + this);
  status.setStatus("Acquiring readlock on region");
  // block waiting for the lock for flushing cache
  lock.readLock().lock();
  try {
    if (this.closed.get()) {
      LOG.debug("Skipping flush on " + this + " because closed");
      status.abort("Skipped: closed");
      return false;
    }
    if (coprocessorHost != null) {
      status.setStatus("Running coprocessor pre-flush hooks");
      coprocessorHost.preFlush();
    }
    if (numPutsWithoutWAL.get() > 0) {
      numPutsWithoutWAL.set(0);
      dataInMemoryWithoutWAL.set(0);
    }
    synchronized (writestate) {
      if (!writestate.flushing && writestate.writesEnabled) {
        this.writestate.flushing = true;
      } else {
        if (LOG.isDebugEnabled()) {
          LOG.debug("NOT flushing memstore for region " + this + ", flushing="
              + writestate.flushing + ", writesEnabled=" + writestate.writesEnabled);
        }
        status.abort("Not flushing since "
            + (writestate.flushing ? "already flushing" : "writes not enabled"));
        return false;
      }
    }
    try {
      boolean result = internalFlushcache(status);

      if (coprocessorHost != null) {
        status.setStatus("Running post-flush coprocessor hooks");
        coprocessorHost.postFlush();
      }

      status.markComplete("Flush successful");
      return result;
    } finally {
      synchronized (writestate) {
        writestate.flushing = false;
        this.writestate.flushRequested = false;
        writestate.notifyAll();
      }
    }
  } finally {
    lock.readLock().unlock();
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Flush the cache.
 *
 * When this method is called the cache will be flushed unless:
 * <ol>
 *   <li>the cache is empty</li>
 *   <li>the region is closed.</li>
 *   <li>a flush is already in progress</li>
 *   <li>writes are disabled</li>
 * </ol>
 *
 * <p>This method may block for some time, so it should not be called from a
 * time-sensitive thread.
 *
 * @return true if the region needs compaction
 *
 * @throws IOException general io exceptions
 * @throws DroppedSnapshotException Thrown when replay of hlog is required
 * because a Snapshot was not properly persisted.
 */
public boolean flushcache() throws IOException {
  // fail-fast instead of waiting on the lock
  if (this.closing.get()) {
    LOG.debug("Skipping flush on " + this + " because closing");
    return false;
  }
  MonitoredTask status = TaskMonitor.get().createStatus("Flushing " + this);
  status.setStatus("Acquiring readlock on region");
  // block waiting for the lock for flushing cache
  lock.readLock().lock();
  try {
    if (this.closed.get()) {
      LOG.debug("Skipping flush on " + this + " because closed");
      status.abort("Skipped: closed");
      return false;
    }
    if (coprocessorHost != null) {
      status.setStatus("Running coprocessor pre-flush hooks");
      coprocessorHost.preFlush();
    }
    if (numPutsWithoutWAL.get() > 0) {
      numPutsWithoutWAL.set(0);
      dataInMemoryWithoutWAL.set(0);
    }
    synchronized (writestate) {
      if (!writestate.flushing && writestate.writesEnabled) {
        this.writestate.flushing = true;
      } else {
        if (LOG.isDebugEnabled()) {
          LOG.debug("NOT flushing memstore for region " + this
              + ", flushing=" + writestate.flushing + ", writesEnabled="
              + writestate.writesEnabled);
        }
        status.abort("Not flushing since "
            + (writestate.flushing ? "already flushing"
                : "writes not enabled"));
        return false;
      }
    }
    try {
      boolean result = internalFlushcache(status);

      if (coprocessorHost != null) {
        status.setStatus("Running post-flush coprocessor hooks");
        coprocessorHost.postFlush();
      }

      status.markComplete("Flush successful");
      return result;
    } finally {
      synchronized (writestate) {
        writestate.flushing = false;
        this.writestate.flushRequested = false;
        writestate.notifyAll();
      }
    }
  } finally {
    lock.readLock().unlock();
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private List<StoreFile> doClose(
    final boolean abort, MonitoredTask status)
throws IOException {
  if (isClosed()) {
    LOG.warn("Region " + this + " already closed");
    return null;
  }

  if (coprocessorHost != null) {
    status.setStatus("Running coprocessor pre-close hooks");
    this.coprocessorHost.preClose(abort);
  }

  status.setStatus("Disabling compacts and flushes for region");
  boolean wasFlushing = false;
  synchronized (writestate) {
    // Disable compacting and flushing by background threads for this
    // region.
    writestate.writesEnabled = false;
    wasFlushing = writestate.flushing;
    LOG.debug("Closing " + this + ": disabling compactions & flushes");
    while (writestate.compacting > 0 || writestate.flushing) {
      LOG.debug("waiting for " + writestate.compacting + " compactions" +
          (writestate.flushing ? " & cache flush" : "") +
          " to complete for region " + this);
      try {
        writestate.wait();
      } catch (InterruptedException iex) {
        // continue
      }
    }
  }
  // If we were not just flushing, is it worth doing a preflush...one
  // that will clear out of the bulk of the memstore before we put up
  // the close flag?
  if (!abort && !wasFlushing && worthPreFlushing()) {
    status.setStatus("Pre-flushing region before close");
    LOG.info("Running close preflush of " + this.getRegionNameAsString());
    internalFlushcache(status);
  }

  this.closing.set(true);
  status.setStatus("Disabling writes for close");
  lock.writeLock().lock();
  try {
    if (this.isClosed()) {
      status.abort("Already got closed by another process");
      // SplitTransaction handles the null
      return null;
    }
    LOG.debug("Updates disabled for region " + this);
    // Don't flush the cache if we are aborting
    if (!abort) {
      internalFlushcache(status);
    }

    List<StoreFile> result = new ArrayList<StoreFile>();
    for (Store store : stores.values()) {
      result.addAll(store.close());
    }
    this.closed.set(true);

    if (coprocessorHost != null) {
      status.setStatus("Running coprocessor post-close hooks");
      this.coprocessorHost.postClose(abort);
    }
    status.markComplete("Closed");
    LOG.info("Closed " + this);
    return result;
  } finally {
    lock.writeLock().unlock();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Flush the cache.
 *
 * When this method is called the cache will be flushed unless:
 * <ol>
 *   <li>the cache is empty</li>
 *   <li>the region is closed.</li>
 *   <li>a flush is already in progress</li>
 *   <li>writes are disabled</li>
 * </ol>
 *
 * <p>This method may block for some time, so it should not be called from a
 * time-sensitive thread.
 *
 * @return true if cache was flushed
 *
 * @throws IOException general io exceptions
 * @throws DroppedSnapshotException Thrown when replay of hlog is required
 * because a Snapshot was not properly persisted.
 */
public boolean flushcache() throws IOException {
  // fail-fast instead of waiting on the lock
  if (this.closing.get()) {
    LOG.debug("Skipping flush on " + this + " because closing");
    return false;
  }
  MonitoredTask status = TaskMonitor.get().createStatus("Flushing " + this);
  status.setStatus("Acquiring readlock on region");
  lock.readLock().lock();
  try {
    if (this.closed.get()) {
      LOG.debug("Skipping flush on " + this + " because closed");
      status.abort("Skipped: closed");
      return false;
    }
    if (coprocessorHost != null) {
      status.setStatus("Running coprocessor pre-flush hooks");
      coprocessorHost.preFlush();
    }
    try {
      synchronized (writestate) {
        if (!writestate.flushing && writestate.writesEnabled) {
          this.writestate.flushing = true;
        } else {
          if (LOG.isDebugEnabled()) {
            LOG.debug("NOT flushing memstore for region " + this +
                ", flushing=" +
                writestate.flushing + ", writesEnabled=" +
                writestate.writesEnabled);
          }
          status.abort("Not flushing since " +
              (writestate.flushing ? "already flushing" : "writes not enabled"));
          return false;
        }
      }
      boolean result = internalFlushcache(status);

      if (coprocessorHost != null) {
        status.setStatus("Running post-flush coprocessor hooks");
        coprocessorHost.postFlush();
      }

      status.markComplete("Flush successful");
      return result;
    } finally {
      synchronized (writestate) {
        writestate.flushing = false;
        this.writestate.flushRequested = false;
        writestate.notifyAll();
      }
    }
  } finally {
    lock.readLock().unlock();
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Flush the cache.
 *
 * When this method is called the cache will be flushed unless:
 * <ol>
 *   <li>the cache is empty</li>
 *   <li>the region is closed.</li>
 *   <li>a flush is already in progress</li>
 *   <li>writes are disabled</li>
 * </ol>
 *
 * <p>This method may block for some time, so it should not be called from a
 * time-sensitive thread.
 *
 * @return true if the region needs compacting
 *
 * @throws IOException general io exceptions
 * @throws DroppedSnapshotException Thrown when replay of hlog is required
 * because a Snapshot was not properly persisted.
 */
public boolean flushcache() throws IOException {
  // fail-fast instead of waiting on the lock
  if (this.closing.get()) {
    LOG.debug("Skipping flush on " + this + " because closing");
    return false;
  }
  MonitoredTask status = TaskMonitor.get().createStatus("Flushing " + this);
  status.setStatus("Acquiring readlock on region");
  // block waiting for the lock for flushing cache
  lock.readLock().lock();
  try {
    if (this.closed.get()) {
      LOG.debug("Skipping flush on " + this + " because closed");
      status.abort("Skipped: closed");
      return false;
    }
    if (coprocessorHost != null) {
      status.setStatus("Running coprocessor pre-flush hooks");
      coprocessorHost.preFlush();
    }
    if (numMutationsWithoutWAL.get() > 0) {
      numMutationsWithoutWAL.set(0);
      dataInMemoryWithoutWAL.set(0);
    }
    synchronized (writestate) {
      if (!writestate.flushing && writestate.writesEnabled) {
        this.writestate.flushing = true;
      } else {
        if (LOG.isDebugEnabled()) {
          LOG.debug("NOT flushing memstore for region " + this
              + ", flushing=" + writestate.flushing + ", writesEnabled="
              + writestate.writesEnabled);
        }
        status.abort("Not flushing since "
            + (writestate.flushing ? "already flushing"
                : "writes not enabled"));
        return false;
      }
    }
    try {
      boolean result = internalFlushcache(status);

      if (coprocessorHost != null) {
        status.setStatus("Running post-flush coprocessor hooks");
        coprocessorHost.postFlush();
      }

      status.markComplete("Flush successful");
      return result;
    } finally {
      synchronized (writestate) {
        writestate.flushing = false;
        this.writestate.flushRequested = false;
        writestate.notifyAll();
      }
    }
  } finally {
    lock.readLock().unlock();
    status.cleanup();
  }
}