Java MonitoredTask.setStatus方法代码示例

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Close down this HRegion. Flush the cache unless abort parameter is true, Shut down each HStore,
 * don't service any more calls. This method could take some time to execute, so don't call it
 * from a time-sensitive thread.
 *
 * @param abort true if server is aborting (only during testing)
 * @return Vector of all the storage files that the HRegion's component HStores make use of. It's
 * a list of HStoreFile objects. Can be null if we are not to close at this time or we are
 * already closed.
 * @throws IOException              e
 * @throws DroppedSnapshotException Thrown when replay of wal is required because a Snapshot was
 *                                  not properly persisted. The region is put in closing mode, and the caller MUST abort
 *                                  after this.
 */
public Map<byte[], List<StoreFile>> close(final boolean abort) throws IOException {
  // Only allow one thread to close at a time. Serialize them so dual
  // threads attempting to close will run up against each other.
  MonitoredTask status =
      TaskMonitor.get().createStatus("Closing region " + this + (abort ? " due to abort" : ""));

  status.setStatus("Waiting for close lock");
  try {
    synchronized (closeLock) {
      return doClose(abort, status);
    }
  } finally {
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private StoreFile commitFile(final Path path, final long logCacheFlushId, MonitoredTask status)
    throws IOException {
  // Write-out finished successfully, move into the right spot
  Path dstPath = fs.commitStoreFile(getColumnFamilyName(), path, this, true);

  status.setStatus("Flushing " + this + ": reopening flushed file");
  StoreFile sf = createStoreFileAndReader(dstPath);

  StoreFile.Reader r = sf.getReader();
  this.storeSize += r.length();
  this.totalUncompressedBytes += r.getTotalUncompressedBytes();

  if (LOG.isInfoEnabled()) {
    LOG.info("Added " + sf + ", entries=" + r.getEntries() + ", sequenceid=" + logCacheFlushId
        + ", filesize=" + TraditionalBinaryPrefix.long2String(r.length(), "", 1));
  }
  return sf;
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Close down this HRegion. Flush the cache unless abort parameter is true, Shut down each HStore,
 * don't service any more calls. This method could take some time to execute, so don't call it
 * from a time-sensitive thread.
 * @param abort true if server is aborting (only during testing)
 * @return Vector of all the storage files that the HRegion's component HStores make use of. It's
 *         a list of HStoreFile objects. Can be null if we are not to close at this time or we are
 *         already closed.
 * @throws IOException e
 */
public List<StoreFile> close(final boolean abort) throws IOException {
  // Only allow one thread to close at a time. Serialize them so dual
  // threads attempting to close will run up against each other.
  MonitoredTask status =
      TaskMonitor.get().createStatus("Closing region " + this + (abort ? " due to abort" : ""));

  status.setStatus("Waiting for close lock");
  try {
    synchronized (closeLock) {
      return doClose(abort, status);
    }
  } finally {
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private StoreFile commitFile(final Path path,
    final long logCacheFlushId,
    TimeRangeTracker snapshotTimeRangeTracker,
    AtomicLong flushedSize,
    MonitoredTask status)
    throws IOException {
  // Write-out finished successfully, move into the right spot
  Path dstPath = fs.commitStoreFile(getColumnFamilyName(), path);

  status.setStatus("Flushing " + this + ": reopening flushed file");
  StoreFile sf = createStoreFileAndReader(dstPath);

  StoreFile.Reader r = sf.getReader();
  this.storeSize += r.length();
  this.totalUncompressedBytes += r.getTotalUncompressedBytes();

  if (LOG.isInfoEnabled()) {
    LOG.info("Added " + sf + ", entries=" + r.getEntries() +
      ", sequenceid=" + logCacheFlushId +
      ", filesize=" + StringUtils.humanReadableInt(r.length()));
  }
  return sf;
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Close down this HRegion.  Flush the cache unless abort parameter is true,
 * Shut down each HStore, don't service any more calls.
 * <p/>
 * This method could take some time to execute, so don't call it from a
 * time-sensitive thread.
 *
 * @param abort true if server is aborting (only during testing)
 * @return Vector of all the storage files that the HRegion's component
 * HStores make use of.  It's a list of HStoreFile objects.  Can be null if
 * we are not to close at this time or we are already closed.
 * @throws IOException e
 */
public Map<byte[], List<StoreFile>> close(final boolean abort) throws IOException {
    // Only allow one thread to close at a time. Serialize them so dual
    // threads attempting to close will run up against each other.
    MonitoredTask status = TaskMonitor.get().createStatus(
            "Closing region " + this +
                    (abort ? " due to abort" : ""));

    status.setStatus("Waiting for close lock");
    try {
        synchronized (closeLock) {
            return doClose(abort, status);
        }
    } finally {
        status.cleanup();
    }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private StoreFile commitFile(final Path path, final long logCacheFlushId, MonitoredTask status)
        throws IOException {
    // Write-out finished successfully, move into the right spot
    Path dstPath = fs.commitStoreFile(getColumnFamilyName(), path);

    status.setStatus("Flushing " + this + ": reopening flushed file");
    StoreFile sf = createStoreFileAndReader(dstPath);

    StoreFile.Reader r = sf.getReader();
    this.storeSize += r.length();
    this.totalUncompressedBytes += r.getTotalUncompressedBytes();

    if (LOG.isInfoEnabled()) {
        LOG.info("Added " + sf + ", entries=" + r.getEntries() +
                ", sequenceid=" + logCacheFlushId +
                ", filesize=" + StringUtils.humanReadableInt(r.length()));
    }
    return sf;
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Close down this HRegion.  Flush the cache unless abort parameter is true,
 * Shut down each HStore, don't service any more calls.
 *
 * This method could take some time to execute, so don't call it from a
 * time-sensitive thread.
 *
 * @param abort true if server is aborting (only during testing)
 * @return Vector of all the storage files that the HRegion's component
 * HStores make use of.  It's a list of HStoreFile objects.  Can be null if
 * we are not to close at this time or we are already closed.
 *
 * @throws IOException e
 */
public Map<byte[], List<StoreFile>> close(final boolean abort) throws IOException {
  // Only allow one thread to close at a time. Serialize them so dual
  // threads attempting to close will run up against each other.
  MonitoredTask status = TaskMonitor.get().createStatus(
      "Closing region " + this +
      (abort ? " due to abort" : ""));

  status.setStatus("Waiting for close lock");
  try {
    synchronized (closeLock) {
      return doClose(abort, status);
    }
  } finally {
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * Close down this HRegion.  Flush the cache unless abort parameter is true,
 * Shut down each HStore, don't service any more calls.
 *
 * This method could take some time to execute, so don't call it from a
 * time-sensitive thread.
 *
 * @param abort true if server is aborting (only during testing)
 * @return Vector of all the storage files that the HRegion's component
 * HStores make use of.  It's a list of HStoreFile objects.  Can be null if
 * we are not to close at this time or we are already closed.
 *
 * @throws IOException e
 */
public List<StoreFile> close(final boolean abort) throws IOException {
  // Only allow one thread to close at a time. Serialize them so dual
  // threads attempting to close will run up against each other.
  MonitoredTask status = TaskMonitor.get().createStatus(
      "Closing region " + this +
      (abort ? " due to abort" : ""));

  status.setStatus("Waiting for close lock");
  try {
    synchronized (closeLock) {
      return doClose(abort, status);
    }
  } finally {
    status.cleanup();
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private StoreFile commitFile(final Path path, final long logCacheFlushId, MonitoredTask status)
    throws IOException {
  // Write-out finished successfully, move into the right spot
  Path dstPath = fs.commitStoreFile(getColumnFamilyName(), path);

  status.setStatus("Flushing " + this + ": reopening flushed file");
  StoreFile sf = createStoreFileAndReader(dstPath);

  StoreFile.Reader r = sf.getReader();
  this.storeSize += r.length();
  this.totalUncompressedBytes += r.getTotalUncompressedBytes();

  if (LOG.isInfoEnabled()) {
    LOG.info("Added " + sf + ", entries=" + r.getEntries() +
      ", sequenceid=" + logCacheFlushId +
      ", filesize=" + StringUtils.humanReadableInt(r.length()));
  }
  return sf;
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
/**
 * @param path The pathname of the tmp file into which the store was flushed
 * @param logCacheFlushId
 * @param status
 * @return store file created.
 * @throws IOException
 */
private HStoreFile commitFile(Path path, long logCacheFlushId, MonitoredTask status)
    throws IOException {
  // Write-out finished successfully, move into the right spot
  Path dstPath = fs.commitStoreFile(getColumnFamilyName(), path);

  status.setStatus("Flushing " + this + ": reopening flushed file");
  HStoreFile sf = createStoreFileAndReader(dstPath);

  StoreFileReader r = sf.getReader();
  this.storeSize.addAndGet(r.length());
  this.totalUncompressedBytes.addAndGet(r.getTotalUncompressedBytes());

  if (LOG.isInfoEnabled()) {
    LOG.info("Added " + sf + ", entries=" + r.getEntries() +
      ", sequenceid=" + logCacheFlushId +
      ", filesize=" + TraditionalBinaryPrefix.long2String(r.length(), "", 1));
  }
  return sf;
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private void waitTasks(TaskBatch batch, MonitoredTask status) {
  synchronized (batch) {
    while ((batch.done + batch.error) != batch.installed) {
      try {
        status.setStatus("Waiting for distributed tasks to finish. "
            + " scheduled=" + batch.installed
            + " done=" + batch.done
            + " error=" + batch.error);
        batch.wait(100);
        if (stopper.isStopped()) {
          LOG.warn("Stopped while waiting for log splits to be completed");
          return;
        }
      } catch (InterruptedException e) {
        LOG.warn("Interrupted while waiting for log splits to be completed");
        Thread.currentThread().interrupt();
        return;
      }
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private void waitForSplittingCompletion(TaskBatch batch, MonitoredTask status) {
  synchronized (batch) {
    while ((batch.done + batch.error) != batch.installed) {
      try {
        status.setStatus("Waiting for distributed tasks to finish. " + " scheduled="
            + batch.installed + " done=" + batch.done + " error=" + batch.error);
        int remaining = batch.installed - (batch.done + batch.error);
        int actual = activeTasks(batch);
        if (remaining != actual) {
          LOG.warn("Expected " + remaining + " active tasks, but actually there are " + actual);
        }
        int remainingTasks =
            ((BaseCoordinatedStateManager) server.getCoordinatedStateManager())
                .getSplitLogManagerCoordination().remainingTasksInCoordination();
        if (remainingTasks >= 0 && actual > remainingTasks) {
          LOG.warn("Expected at least" + actual + " tasks remaining, but actually there are "
              + remainingTasks);
        }
        if (remainingTasks == 0 || actual == 0) {
          LOG.warn("No more task remaining, splitting "
              + "should have completed. Remaining tasks is " + remainingTasks
              + ", active tasks in map " + actual);
          if (remainingTasks == 0 && actual == 0) {
            return;
          }
        }
        batch.wait(100);
        if (stopper.isStopped()) {
          LOG.warn("Stopped while waiting for log splits to be completed");
          return;
        }
      } catch (InterruptedException e) {
        LOG.warn("Interrupted while waiting for log splits to be completed");
        Thread.currentThread().interrupt();
        return;
      }
    }
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private void initializeWarmup(final CancelableProgressable reporter) throws IOException {
  MonitoredTask status = TaskMonitor.get().createStatus("Initializing region " + this);
  // Initialize all the HStores
  status.setStatus("Warming up all the Stores");
  try {
    initializeStores(reporter, status);
  } finally {
    status.markComplete("Done warming up.");
  }
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
protected void finalizeWriter(StoreFile.Writer writer, long cacheFlushSeqNum,
    MonitoredTask status) throws IOException {
  // Write out the log sequence number that corresponds to this output
  // hfile. Also write current time in metadata as minFlushTime.
  // The hfile is current up to and including cacheFlushSeqNum.
  status.setStatus("Flushing " + store + ": appending metadata");
  writer.appendMetadata(cacheFlushSeqNum, false);
  status.setStatus("Flushing " + store + ": closing flushed file");
  writer.close();
}
 

import org.apache.hadoop.hbase.monitoring.MonitoredTask; //导入方法依赖的package包/类
private void waitForSplittingCompletion(TaskBatch batch, MonitoredTask status) {
  synchronized (batch) {
    while ((batch.done + batch.error) != batch.installed) {
      try {
        status.setStatus("Waiting for distributed tasks to finish. "
            + " scheduled=" + batch.installed
            + " done=" + batch.done
            + " error=" + batch.error);
        int remaining = batch.installed - (batch.done + batch.error);
        int actual = activeTasks(batch);
        if (remaining != actual) {
          LOG.warn("Expected " + remaining
            + " active tasks, but actually there are " + actual);
        }
        int remainingInZK = remainingTasksInZK();
        if (remainingInZK >= 0 && actual > remainingInZK) {
          LOG.warn("Expected at least" + actual
            + " tasks in ZK, but actually there are " + remainingInZK);
        }
        if (remainingInZK == 0 || actual == 0) {
          LOG.warn("No more task remaining (ZK or task map), splitting "
            + "should have completed. Remaining tasks in ZK " + remainingInZK
            + ", active tasks in map " + actual);
          if (remainingInZK == 0 && actual == 0) {
            return;
          }
        }
        batch.wait(100);
        if (stopper.isStopped()) {
          LOG.warn("Stopped while waiting for log splits to be completed");
          return;
        }
      } catch (InterruptedException e) {
        LOG.warn("Interrupted while waiting for log splits to be completed");
        Thread.currentThread().interrupt();
        return;
      }
    }
  }
}