Java 类org.apache.hadoop.hbase.monitoring.TaskMonitor 实例源码

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getTableName(), masterServices, masterServices);

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getTableName());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd,
    final MasterMetrics metricsMaster) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getName(), masterServices, masterServices);
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getNameAsString());
}

public CloneSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor,
    final MasterMetrics metricsMaster)
    throws NotAllMetaRegionsOnlineException, TableExistsException, IOException {
  super(masterServices, masterServices.getMasterFileSystem(),
    masterServices.getServerManager(), hTableDescriptor,
    masterServices.getConfiguration(), null, masterServices.getCatalogTracker(),
    masterServices.getAssignmentManager());
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();
  this.status = TaskMonitor.get().createStatus("Cloning  snapshot '" + snapshot.getName() +
    "' to table " + hTableDescriptor.getNameAsString());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getTableName(), masterServices, masterServices);

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getTableName());
}

/**
 * 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.");
        }
    }
}

/**
 * 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();
    }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getTableName(), masterServices, masterServices);

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getTableName());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd,
    final MasterMetrics metricsMaster) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getName(), masterServices, masterServices);
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getNameAsString());
}

public CloneSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor,
    final MasterMetrics metricsMaster)
    throws NotAllMetaRegionsOnlineException, TableExistsException, IOException {
  super(masterServices, masterServices.getMasterFileSystem(),
    masterServices.getServerManager(), hTableDescriptor,
    masterServices.getConfiguration(), null, masterServices.getCatalogTracker(),
    masterServices.getAssignmentManager());
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();
  this.status = TaskMonitor.get().createStatus("Cloning  snapshot '" + snapshot.getName() +
    "' to table " + hTableDescriptor.getNameAsString());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getTableName(), masterServices, masterServices);

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getTableName());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getTableName(), masterServices, masterServices);

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getTableName());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd,
    final MasterMetrics metricsMaster) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getName(), masterServices, masterServices);
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getNameAsString());
}

public CloneSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor,
    final MasterMetrics metricsMaster)
    throws NotAllMetaRegionsOnlineException, TableExistsException, IOException {
  super(masterServices, masterServices.getMasterFileSystem(),
    masterServices.getServerManager(), hTableDescriptor,
    masterServices.getConfiguration(), null, masterServices.getCatalogTracker(),
    masterServices.getAssignmentManager());
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();
  this.status = TaskMonitor.get().createStatus("Cloning  snapshot '" + snapshot.getName() +
    "' to table " + hTableDescriptor.getNameAsString());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd,
    final MasterMetrics metricsMaster) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getName(), masterServices, masterServices);
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getNameAsString());
}

public CloneSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor,
    final MasterMetrics metricsMaster)
    throws NotAllMetaRegionsOnlineException, TableExistsException, IOException {
  super(masterServices, masterServices.getMasterFileSystem(),
    masterServices.getServerManager(), hTableDescriptor,
    masterServices.getConfiguration(), null, masterServices.getCatalogTracker(),
    masterServices.getAssignmentManager());
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();
  this.status = TaskMonitor.get().createStatus("Cloning  snapshot '" + snapshot.getName() +
    "' to table " + hTableDescriptor.getNameAsString());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd,
    final MasterMetrics metricsMaster) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getName(), masterServices, masterServices);
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getNameAsString());
}

public CloneSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor hTableDescriptor,
    final MasterMetrics metricsMaster)
    throws NotAllMetaRegionsOnlineException, TableExistsException, IOException {
  super(masterServices, masterServices.getMasterFileSystem(),
    masterServices.getServerManager(), hTableDescriptor,
    masterServices.getConfiguration(), null, masterServices.getCatalogTracker(),
    masterServices.getAssignmentManager());
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();
  this.status = TaskMonitor.get().createStatus("Cloning  snapshot '" + snapshot.getName() +
    "' to table " + hTableDescriptor.getNameAsString());
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

/**
 * 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.");
    }
  }
}

/**
 * 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();
  }
}

public RestoreSnapshotHandler(final MasterServices masterServices,
    final SnapshotDescription snapshot, final HTableDescriptor htd,
    final MasterMetrics metricsMaster) throws IOException {
  super(EventType.C_M_RESTORE_SNAPSHOT, htd.getName(), masterServices, masterServices);
  this.metricsMaster = metricsMaster;

  // Snapshot information
  this.snapshot = snapshot;

  // Monitor
  this.monitor = new ForeignExceptionDispatcher();

  // Check table exists.
  getTableDescriptor();

  // This is the new schema we are going to write out as this modification.
  this.hTableDescriptor = htd;

  this.status = TaskMonitor.get().createStatus(
    "Restoring  snapshot '" + snapshot.getName() + "' to table "
        + hTableDescriptor.getNameAsString());
}