Java 类org.apache.hadoop.hbase.snapshot.HBaseSnapshotException 实例源码

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(TableName.valueOf(snapshot.getTable()), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            ClientSnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          ClientSnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(snapshot.getTable(), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            SnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          SnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(TableName.valueOf(snapshot.getTable()), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            ClientSnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          ClientSnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(TableName.valueOf(snapshot.getTable()), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            ClientSnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          ClientSnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(snapshot.getTable(), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            SnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          SnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(TableName.valueOf(snapshot.getTable()), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            ClientSnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          ClientSnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e,
      ProtobufUtil.createSnapshotDesc(snapshot));
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(TableName.valueOf(snapshot.getTable()), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            ClientSnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          ClientSnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(TableName.valueOf(snapshot.getTable()), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            ClientSnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          ClientSnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(snapshot.getTable(), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            SnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          SnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(snapshot.getTable(), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            SnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          SnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(snapshot.getTable(), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            SnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          SnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Take a snapshot using the specified handler.
 * On failure the snapshot temporary working directory is removed.
 * NOTE: prepareToTakeSnapshot() called before this one takes care of the rejecting the
 *       snapshot request if the table is busy with another snapshot/restore operation.
 * @param snapshot the snapshot description
 * @param handler the snapshot handler
 */
private synchronized void snapshotTable(SnapshotDescription snapshot,
    final TakeSnapshotHandler handler) throws HBaseSnapshotException {
  try {
    handler.prepare();
    this.executorService.submit(handler);
    this.snapshotHandlers.put(snapshot.getTable(), handler);
  } catch (Exception e) {
    // cleanup the working directory by trying to delete it from the fs.
    Path workingDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
    try {
      if (!this.master.getMasterFileSystem().getFileSystem().delete(workingDir, true)) {
        LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
            SnapshotDescriptionUtils.toString(snapshot));
      }
    } catch (IOException e1) {
      LOG.error("Couldn't delete working directory (" + workingDir + " for snapshot:" +
          SnapshotDescriptionUtils.toString(snapshot));
    }
    // fail the snapshot
    throw new SnapshotCreationException("Could not build snapshot handler", e, snapshot);
  }
}

/**
 * Delete the specified snapshot
 * @param snapshot
 * @throws SnapshotDoesNotExistException If the specified snapshot does not exist.
 * @throws IOException For filesystem IOExceptions
 */
public void deleteSnapshot(SnapshotDescription snapshot) throws SnapshotDoesNotExistException, IOException {
  // check to see if it is completed
  if (!isSnapshotCompleted(snapshot)) {
    throw new SnapshotDoesNotExistException(snapshot);
  }

  String snapshotName = snapshot.getName();
  // first create the snapshot description and check to see if it exists
  FileSystem fs = master.getMasterFileSystem().getFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);
  // Get snapshot info from file system. The one passed as parameter is a "fake" snapshotInfo with
  // just the "name" and it does not contains the "real" snapshot information
  snapshot = SnapshotDescriptionUtils.readSnapshotInfo(fs, snapshotDir);

  // call coproc pre hook
  MasterCoprocessorHost cpHost = master.getMasterCoprocessorHost();
  if (cpHost != null) {
    cpHost.preDeleteSnapshot(snapshot);
  }

  LOG.debug("Deleting snapshot: " + snapshotName);
  // delete the existing snapshot
  if (!fs.delete(snapshotDir, true)) {
    throw new HBaseSnapshotException("Failed to delete snapshot directory: " + snapshotDir);
  }

  // call coproc post hook
  if (cpHost != null) {
    cpHost.postDeleteSnapshot(snapshot);
  }

}

/**
 * Take a snapshot of a disabled table.
 * @param snapshot description of the snapshot to take. Modified to be {@link Type#DISABLED}.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotDisabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // set the snapshot to be a disabled snapshot, since the client doesn't know about that
  snapshot = snapshot.toBuilder().setType(Type.DISABLED).build();

  // Take the snapshot of the disabled table
  DisabledTableSnapshotHandler handler =
      new DisabledTableSnapshotHandler(snapshot, master);
  snapshotTable(snapshot, handler);
}

/**
 * Take a snapshot of an enabled table.
 * @param snapshot description of the snapshot to take.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotEnabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // Take the snapshot of the enabled table
  EnabledTableSnapshotHandler handler =
      new EnabledTableSnapshotHandler(snapshot, master, this);
  snapshotTable(snapshot, handler);
}

/**
 * Clone the specified snapshot into a new table.
 * The operation will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor of the table to create
 */
synchronized void cloneSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  TableName tableName = hTableDescriptor.getTableName();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    CloneSnapshotHandler handler =
      new CloneSnapshotHandler(master, snapshot, hTableDescriptor).prepare();
    this.executorService.submit(handler);
    this.restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't clone the snapshot=" + ClientSnapshotDescriptionUtils.toString(snapshot) +
      " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Restore the specified snapshot.
 * The restore will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor
 */
private synchronized void restoreSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  TableName tableName = hTableDescriptor.getTableName();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    RestoreSnapshotHandler handler =
      new RestoreSnapshotHandler(master, snapshot, hTableDescriptor).prepare();
    this.executorService.submit(handler);
    restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't restore the snapshot=" + ClientSnapshotDescriptionUtils.toString(
        snapshot)  +
        " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Delete the specified snapshot
 * @param snapshot
 * @throws SnapshotDoesNotExistException If the specified snapshot does not exist.
 * @throws IOException For filesystem IOExceptions
 */
public void deleteSnapshot(SnapshotDescription snapshot) throws SnapshotDoesNotExistException, IOException {

  // call coproc pre hook
  MasterCoprocessorHost cpHost = master.getCoprocessorHost();
  if (cpHost != null) {
    cpHost.preDeleteSnapshot(snapshot);
  }

  // check to see if it is completed
  if (!isSnapshotCompleted(snapshot)) {
    throw new SnapshotDoesNotExistException(snapshot);
  }

  String snapshotName = snapshot.getName();
  LOG.debug("Deleting snapshot: " + snapshotName);
  // first create the snapshot description and check to see if it exists
  MasterFileSystem fs = master.getMasterFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);

  // delete the existing snapshot
  if (!fs.getFileSystem().delete(snapshotDir, true)) {
    throw new HBaseSnapshotException("Failed to delete snapshot directory: " + snapshotDir);
  }

  // call coproc post hook
  if (cpHost != null) {
    cpHost.postDeleteSnapshot(snapshot);
  }

}

/**
 * Take a snapshot of a disabled table.
 * @param snapshot description of the snapshot to take. Modified to be {@link Type#DISABLED}.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotDisabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // set the snapshot to be a disabled snapshot, since the client doesn't know about that
  snapshot = snapshot.toBuilder().setType(Type.DISABLED).build();

  // Take the snapshot of the disabled table
  DisabledTableSnapshotHandler handler =
      new DisabledTableSnapshotHandler(snapshot, master, metricsMaster);
  snapshotTable(snapshot, handler);
}

/**
 * Take a snapshot of an enabled table.
 * @param snapshot description of the snapshot to take.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotEnabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // Take the snapshot of the enabled table
  EnabledTableSnapshotHandler handler =
      new EnabledTableSnapshotHandler(snapshot, master, this, metricsMaster);
  snapshotTable(snapshot, handler);
}

/**
 * Clone the specified snapshot into a new table.
 * The operation will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor of the table to create
 */
synchronized void cloneSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  String tableName = hTableDescriptor.getNameAsString();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    CloneSnapshotHandler handler =
      new CloneSnapshotHandler(master, snapshot, hTableDescriptor, metricsMaster);
    this.executorService.submit(handler);
    this.restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't clone the snapshot=" + SnapshotDescriptionUtils.toString(snapshot) +
      " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Restore the specified snapshot.
 * The restore will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor
 */
private synchronized void restoreSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  String tableName = hTableDescriptor.getNameAsString();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    RestoreSnapshotHandler handler =
      new RestoreSnapshotHandler(master, snapshot, hTableDescriptor, metricsMaster);
    this.executorService.submit(handler);
    restoreHandlers.put(hTableDescriptor.getNameAsString(), handler);
  } catch (Exception e) {
    String msg = "Couldn't restore the snapshot=" + SnapshotDescriptionUtils.toString(
        snapshot)  +
        " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Delete the specified snapshot
 * @param snapshot
 * @throws SnapshotDoesNotExistException If the specified snapshot does not exist.
 * @throws IOException For filesystem IOExceptions
 */
public void deleteSnapshot(SnapshotDescription snapshot) throws SnapshotDoesNotExistException, IOException {

  // call coproc pre hook
  MasterCoprocessorHost cpHost = master.getMasterCoprocessorHost();
  if (cpHost != null) {
    cpHost.preDeleteSnapshot(snapshot);
  }

  // check to see if it is completed
  if (!isSnapshotCompleted(snapshot)) {
    throw new SnapshotDoesNotExistException(snapshot);
  }

  String snapshotName = snapshot.getName();
  LOG.debug("Deleting snapshot: " + snapshotName);
  // first create the snapshot description and check to see if it exists
  MasterFileSystem fs = master.getMasterFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);

  // delete the existing snapshot
  if (!fs.getFileSystem().delete(snapshotDir, true)) {
    throw new HBaseSnapshotException("Failed to delete snapshot directory: " + snapshotDir);
  }

  // call coproc post hook
  if (cpHost != null) {
    cpHost.postDeleteSnapshot(snapshot);
  }

}

/**
 * Take a snapshot of a disabled table.
 * @param snapshot description of the snapshot to take. Modified to be {@link Type#DISABLED}.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotDisabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // set the snapshot to be a disabled snapshot, since the client doesn't know about that
  snapshot = snapshot.toBuilder().setType(Type.DISABLED).build();

  // Take the snapshot of the disabled table
  DisabledTableSnapshotHandler handler =
      new DisabledTableSnapshotHandler(snapshot, master);
  snapshotTable(snapshot, handler);
}

/**
 * Take a snapshot of an enabled table.
 * @param snapshot description of the snapshot to take.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotEnabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // Take the snapshot of the enabled table
  EnabledTableSnapshotHandler handler =
      new EnabledTableSnapshotHandler(snapshot, master, this);
  snapshotTable(snapshot, handler);
}

/**
 * Clone the specified snapshot into a new table.
 * The operation will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor of the table to create
 */
synchronized void cloneSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  TableName tableName = hTableDescriptor.getTableName();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    CloneSnapshotHandler handler =
      new CloneSnapshotHandler(master, snapshot, hTableDescriptor).prepare();
    this.executorService.submit(handler);
    this.restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't clone the snapshot=" + ClientSnapshotDescriptionUtils.toString(snapshot) +
      " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Restore the specified snapshot.
 * The restore will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor
 */
private synchronized void restoreSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  TableName tableName = hTableDescriptor.getTableName();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    RestoreSnapshotHandler handler =
      new RestoreSnapshotHandler(master, snapshot, hTableDescriptor).prepare();
    this.executorService.submit(handler);
    restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't restore the snapshot=" + ClientSnapshotDescriptionUtils.toString(
        snapshot)  +
        " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Delete the specified snapshot
 * @param snapshot
 * @throws SnapshotDoesNotExistException If the specified snapshot does not exist.
 * @throws IOException For filesystem IOExceptions
 */
public void deleteSnapshot(SnapshotDescription snapshot) throws SnapshotDoesNotExistException, IOException {

  // call coproc pre hook
  MasterCoprocessorHost cpHost = master.getCoprocessorHost();
  if (cpHost != null) {
    cpHost.preDeleteSnapshot(snapshot);
  }

  // check to see if it is completed
  if (!isSnapshotCompleted(snapshot)) {
    throw new SnapshotDoesNotExistException(snapshot);
  }

  String snapshotName = snapshot.getName();
  LOG.debug("Deleting snapshot: " + snapshotName);
  // first create the snapshot description and check to see if it exists
  MasterFileSystem fs = master.getMasterFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);

  // delete the existing snapshot
  if (!fs.getFileSystem().delete(snapshotDir, true)) {
    throw new HBaseSnapshotException("Failed to delete snapshot directory: " + snapshotDir);
  }

  // call coproc post hook
  if (cpHost != null) {
    cpHost.postDeleteSnapshot(snapshot);
  }

}

/**
 * Take a snapshot of a disabled table.
 * @param snapshot description of the snapshot to take. Modified to be {@link Type#DISABLED}.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotDisabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // set the snapshot to be a disabled snapshot, since the client doesn't know about that
  snapshot = snapshot.toBuilder().setType(Type.DISABLED).build();

  // Take the snapshot of the disabled table
  DisabledTableSnapshotHandler handler =
      new DisabledTableSnapshotHandler(snapshot, master);
  snapshotTable(snapshot, handler);
}

/**
 * Take a snapshot of an enabled table.
 * @param snapshot description of the snapshot to take.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotEnabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // Take the snapshot of the enabled table
  EnabledTableSnapshotHandler handler =
      new EnabledTableSnapshotHandler(snapshot, master, this);
  snapshotTable(snapshot, handler);
}

/**
 * Clone the specified snapshot into a new table.
 * The operation will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor of the table to create
 */
synchronized void cloneSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  TableName tableName = hTableDescriptor.getTableName();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    CloneSnapshotHandler handler =
      new CloneSnapshotHandler(master, snapshot, hTableDescriptor).prepare();
    this.executorService.submit(handler);
    this.restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't clone the snapshot=" + ClientSnapshotDescriptionUtils.toString(snapshot) +
      " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Restore the specified snapshot.
 * The restore will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor
 */
private synchronized void restoreSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  TableName tableName = hTableDescriptor.getTableName();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    RestoreSnapshotHandler handler =
      new RestoreSnapshotHandler(master, snapshot, hTableDescriptor).prepare();
    this.executorService.submit(handler);
    restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't restore the snapshot=" + ClientSnapshotDescriptionUtils.toString(
        snapshot)  +
        " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Delete the specified snapshot
 * @param snapshot
 * @throws SnapshotDoesNotExistException If the specified snapshot does not exist.
 * @throws IOException For filesystem IOExceptions
 */
public void deleteSnapshot(SnapshotDescription snapshot) throws SnapshotDoesNotExistException, IOException {

  // call coproc pre hook
  MasterCoprocessorHost cpHost = master.getCoprocessorHost();
  if (cpHost != null) {
    cpHost.preDeleteSnapshot(snapshot);
  }

  // check to see if it is completed
  if (!isSnapshotCompleted(snapshot)) {
    throw new SnapshotDoesNotExistException(snapshot);
  }

  String snapshotName = snapshot.getName();
  LOG.debug("Deleting snapshot: " + snapshotName);
  // first create the snapshot description and check to see if it exists
  MasterFileSystem fs = master.getMasterFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);

  // delete the existing snapshot
  if (!fs.getFileSystem().delete(snapshotDir, true)) {
    throw new HBaseSnapshotException("Failed to delete snapshot directory: " + snapshotDir);
  }

  // call coproc post hook
  if (cpHost != null) {
    cpHost.postDeleteSnapshot(snapshot);
  }

}

/**
 * Take a snapshot of a disabled table.
 * @param snapshot description of the snapshot to take. Modified to be {@link Type#DISABLED}.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotDisabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // set the snapshot to be a disabled snapshot, since the client doesn't know about that
  snapshot = snapshot.toBuilder().setType(Type.DISABLED).build();

  // Take the snapshot of the disabled table
  DisabledTableSnapshotHandler handler =
      new DisabledTableSnapshotHandler(snapshot, master, metricsMaster);
  snapshotTable(snapshot, handler);
}

/**
 * Take a snapshot of an enabled table.
 * @param snapshot description of the snapshot to take.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotEnabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // Take the snapshot of the enabled table
  EnabledTableSnapshotHandler handler =
      new EnabledTableSnapshotHandler(snapshot, master, this, metricsMaster);
  snapshotTable(snapshot, handler);
}

/**
 * Clone the specified snapshot into a new table.
 * The operation will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor of the table to create
 */
synchronized void cloneSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  String tableName = hTableDescriptor.getNameAsString();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    CloneSnapshotHandler handler =
      new CloneSnapshotHandler(master, snapshot, hTableDescriptor, metricsMaster);
    this.executorService.submit(handler);
    this.restoreHandlers.put(tableName, handler);
  } catch (Exception e) {
    String msg = "Couldn't clone the snapshot=" + SnapshotDescriptionUtils.toString(snapshot) +
      " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Restore the specified snapshot.
 * The restore will fail if the destination table has a snapshot or restore in progress.
 *
 * @param snapshot Snapshot Descriptor
 * @param hTableDescriptor Table Descriptor
 */
private synchronized void restoreSnapshot(final SnapshotDescription snapshot,
    final HTableDescriptor hTableDescriptor) throws HBaseSnapshotException {
  String tableName = hTableDescriptor.getNameAsString();

  // make sure we aren't running a snapshot on the same table
  if (isTakingSnapshot(tableName)) {
    throw new RestoreSnapshotException("Snapshot in progress on the restore table=" + tableName);
  }

  // make sure we aren't running a restore on the same table
  if (isRestoringTable(tableName)) {
    throw new RestoreSnapshotException("Restore already in progress on the table=" + tableName);
  }

  try {
    RestoreSnapshotHandler handler =
      new RestoreSnapshotHandler(master, snapshot, hTableDescriptor, metricsMaster);
    this.executorService.submit(handler);
    restoreHandlers.put(hTableDescriptor.getNameAsString(), handler);
  } catch (Exception e) {
    String msg = "Couldn't restore the snapshot=" + SnapshotDescriptionUtils.toString(
        snapshot)  +
        " on table=" + tableName;
    LOG.error(msg, e);
    throw new RestoreSnapshotException(msg, e);
  }
}

/**
 * Delete the specified snapshot
 * @param snapshot
 * @throws SnapshotDoesNotExistException If the specified snapshot does not exist.
 * @throws IOException For filesystem IOExceptions
 */
public void deleteSnapshot(SnapshotDescription snapshot) throws SnapshotDoesNotExistException, IOException {
  // check to see if it is completed
  if (!isSnapshotCompleted(snapshot)) {
    throw new SnapshotDoesNotExistException(ProtobufUtil.createSnapshotDesc(snapshot));
  }

  String snapshotName = snapshot.getName();
  // first create the snapshot description and check to see if it exists
  FileSystem fs = master.getMasterFileSystem().getFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);
  // Get snapshot info from file system. The one passed as parameter is a "fake" snapshotInfo with
  // just the "name" and it does not contains the "real" snapshot information
  snapshot = SnapshotDescriptionUtils.readSnapshotInfo(fs, snapshotDir);

  // call coproc pre hook
  MasterCoprocessorHost cpHost = master.getMasterCoprocessorHost();
  org.apache.hadoop.hbase.client.SnapshotDescription snapshotPOJO = null;
  if (cpHost != null) {
    snapshotPOJO = ProtobufUtil.createSnapshotDesc(snapshot);
    cpHost.preDeleteSnapshot(snapshotPOJO);
  }

  LOG.debug("Deleting snapshot: " + snapshotName);
  // delete the existing snapshot
  if (!fs.delete(snapshotDir, true)) {
    throw new HBaseSnapshotException("Failed to delete snapshot directory: " + snapshotDir);
  }

  // call coproc post hook
  if (cpHost != null) {
    cpHost.postDeleteSnapshot(snapshotPOJO);
  }

}

/**
 * Take a snapshot of a disabled table.
 * @param snapshot description of the snapshot to take. Modified to be {@link Type#DISABLED}.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotDisabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // set the snapshot to be a disabled snapshot, since the client doesn't know about that
  snapshot = snapshot.toBuilder().setType(Type.DISABLED).build();

  // Take the snapshot of the disabled table
  DisabledTableSnapshotHandler handler =
      new DisabledTableSnapshotHandler(snapshot, master, this);
  snapshotTable(snapshot, handler);
}

/**
 * Take a snapshot of an enabled table.
 * @param snapshot description of the snapshot to take.
 * @throws HBaseSnapshotException if the snapshot could not be started
 */
private synchronized void snapshotEnabledTable(SnapshotDescription snapshot)
    throws HBaseSnapshotException {
  // setup the snapshot
  prepareToTakeSnapshot(snapshot);

  // Take the snapshot of the enabled table
  EnabledTableSnapshotHandler handler =
      new EnabledTableSnapshotHandler(snapshot, master, this);
  snapshotTable(snapshot, handler);
}