Java Code Examples for org.apache.hadoop.hbase.shaded.protobuf.ProtobufUtil#createSnapshotDesc()

/**
 * 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 IOException {
  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,
        master.getConfiguration());
    FileSystem workingDirFs = workingDir.getFileSystem(master.getConfiguration());
    try {
      if (!workingDirFs.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));
  }
}
 

/**
 * Clone the specified snapshot.
 * The clone will fail if the destination table has a snapshot or restore in progress.
 *
 * @param reqSnapshot Snapshot Descriptor from request
 * @param tableName table to clone
 * @param snapshot Snapshot Descriptor
 * @param snapshotTableDesc Table Descriptor
 * @param nonceKey unique identifier to prevent duplicated RPC
 * @return procId the ID of the clone snapshot procedure
 * @throws IOException
 */
private long cloneSnapshot(final SnapshotDescription reqSnapshot, final TableName tableName,
    final SnapshotDescription snapshot, final TableDescriptor snapshotTableDesc,
    final NonceKey nonceKey, final boolean restoreAcl) throws IOException {
  MasterCoprocessorHost cpHost = master.getMasterCoprocessorHost();
  TableDescriptor htd = TableDescriptorBuilder.copy(tableName, snapshotTableDesc);
  org.apache.hadoop.hbase.client.SnapshotDescription snapshotPOJO = null;
  if (cpHost != null) {
    snapshotPOJO = ProtobufUtil.createSnapshotDesc(snapshot);
    cpHost.preCloneSnapshot(snapshotPOJO, htd);
  }
  long procId;
  try {
    procId = cloneSnapshot(snapshot, htd, nonceKey, restoreAcl);
  } catch (IOException e) {
    LOG.error("Exception occurred while cloning the snapshot " + snapshot.getName()
      + " as table " + tableName.getNameAsString(), e);
    throw e;
  }
  LOG.info("Clone snapshot=" + snapshot.getName() + " as table=" + tableName);

  if (cpHost != null) {
    cpHost.postCloneSnapshot(snapshotPOJO, htd);
  }
  return procId;
}
 

/**
 * Check that the snapshot description written in the filesystem matches the current snapshot
 * @param snapshotDir snapshot directory to check
 */
private void verifySnapshotDescription(Path snapshotDir) throws CorruptedSnapshotException {
  SnapshotDescription found = SnapshotDescriptionUtils.readSnapshotInfo(workingDirFs,
      snapshotDir);
  if (!this.snapshot.equals(found)) {
    throw new CorruptedSnapshotException(
        "Snapshot read (" + found + ") doesn't equal snapshot we ran (" + snapshot + ").",
        ProtobufUtil.createSnapshotDesc(snapshot));
  }
}
 

/**
 * Check that the table descriptor for the snapshot is a valid table descriptor
 * @param manifest snapshot manifest to inspect
 */
private void verifyTableInfo(final SnapshotManifest manifest) throws IOException {
  TableDescriptor htd = manifest.getTableDescriptor();
  if (htd == null) {
    throw new CorruptedSnapshotException("Missing Table Descriptor",
      ProtobufUtil.createSnapshotDesc(snapshot));
  }

  if (!htd.getTableName().getNameAsString().equals(snapshot.getTable())) {
    throw new CorruptedSnapshotException(
        "Invalid Table Descriptor. Expected " + snapshot.getTable() + " name, got "
            + htd.getTableName().getNameAsString(), ProtobufUtil.createSnapshotDesc(snapshot));
  }
}
 

/**
 * Verify that the regionInfo is valid
 * @param region the region to check
 * @param manifest snapshot manifest to inspect
 */
private void verifyRegionInfo(final RegionInfo region,
    final SnapshotRegionManifest manifest) throws IOException {
  RegionInfo manifestRegionInfo = ProtobufUtil.toRegionInfo(manifest.getRegionInfo());
  if (RegionInfo.COMPARATOR.compare(region, manifestRegionInfo) != 0) {
    String msg = "Manifest region info " + manifestRegionInfo +
                 "doesn't match expected region:" + region;
    throw new CorruptedSnapshotException(msg, ProtobufUtil.createSnapshotDesc(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 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);
  }

}
 

/**
 * Restore the specified snapshot. The restore will fail if the destination table has a snapshot
 * or restore in progress.
 * @param reqSnapshot Snapshot Descriptor from request
 * @param tableName table to restore
 * @param snapshot Snapshot Descriptor
 * @param snapshotTableDesc Table Descriptor
 * @param nonceKey unique identifier to prevent duplicated RPC
 * @param restoreAcl true to restore acl of snapshot
 * @return procId the ID of the restore snapshot procedure
 * @throws IOException
 */
private long restoreSnapshot(final SnapshotDescription reqSnapshot, final TableName tableName,
    final SnapshotDescription snapshot, final TableDescriptor snapshotTableDesc,
    final NonceKey nonceKey, final boolean restoreAcl) throws IOException {
  MasterCoprocessorHost cpHost = master.getMasterCoprocessorHost();

  if (master.getTableStateManager().isTableState(
    TableName.valueOf(snapshot.getTable()), TableState.State.ENABLED)) {
    throw new UnsupportedOperationException("Table '" +
      TableName.valueOf(snapshot.getTable()) + "' must be disabled in order to " +
      "perform a restore operation.");
  }

  // call Coprocessor pre hook
  org.apache.hadoop.hbase.client.SnapshotDescription snapshotPOJO = null;
  if (cpHost != null) {
    snapshotPOJO = ProtobufUtil.createSnapshotDesc(snapshot);
    cpHost.preRestoreSnapshot(snapshotPOJO, snapshotTableDesc);
  }

  long procId;
  try {
    procId = restoreSnapshot(snapshot, snapshotTableDesc, nonceKey, restoreAcl);
  } catch (IOException e) {
    LOG.error("Exception occurred while restoring the snapshot " + snapshot.getName()
      + " as table " + tableName.getNameAsString(), e);
    throw e;
  }
  LOG.info("Restore snapshot=" + snapshot.getName() + " as table=" + tableName);

  if (cpHost != null) {
    cpHost.postRestoreSnapshot(snapshotPOJO, snapshotTableDesc);
  }

  return procId;
}
 

private RegionVisitor createRegionVisitor(final SnapshotDescription desc) throws IOException {
  switch (getSnapshotFormat(desc)) {
    case SnapshotManifestV1.DESCRIPTOR_VERSION:
      return new SnapshotManifestV1.ManifestBuilder(conf, rootFs, workingDir);
    case SnapshotManifestV2.DESCRIPTOR_VERSION:
      return new SnapshotManifestV2.ManifestBuilder(conf, rootFs, workingDir);
    default:
    throw new CorruptedSnapshotException("Invalid Snapshot version: " + desc.getVersion(),
      ProtobufUtil.createSnapshotDesc(desc));
  }
}
 

/**
 * Check if the specified snapshot is done
 *
 * @param expected
 * @return true if snapshot is ready to be restored, false if it is still being taken.
 * @throws IOException IOException if error from HDFS or RPC
 * @throws UnknownSnapshotException if snapshot is invalid or does not exist.
 */
public boolean isSnapshotDone(SnapshotDescription expected) throws IOException {
  // check the request to make sure it has a snapshot
  if (expected == null) {
    throw new UnknownSnapshotException(
       "No snapshot name passed in request, can't figure out which snapshot you want to check.");
  }

  String ssString = ClientSnapshotDescriptionUtils.toString(expected);

  // check to see if the sentinel exists,
  // and if the task is complete removes it from the in-progress snapshots map.
  SnapshotSentinel handler = removeSentinelIfFinished(this.snapshotHandlers, expected);

  // stop tracking "abandoned" handlers
  cleanupSentinels();

  if (handler == null) {
    // If there's no handler in the in-progress map, it means one of the following:
    //   - someone has already requested the snapshot state
    //   - the requested snapshot was completed long time ago (cleanupSentinels() timeout)
    //   - the snapshot was never requested
    // In those cases returns to the user the "done state" if the snapshots exists on disk,
    // otherwise raise an exception saying that the snapshot is not running and doesn't exist.
    if (!isSnapshotCompleted(expected)) {
      throw new UnknownSnapshotException("Snapshot " + ssString
          + " is not currently running or one of the known completed snapshots.");
    }
    // was done, return true;
    return true;
  }

  // pass on any failure we find in the sentinel
  try {
    handler.rethrowExceptionIfFailed();
  } catch (ForeignException e) {
    // Give some procedure info on an exception.
    String status;
    Procedure p = coordinator.getProcedure(expected.getName());
    if (p != null) {
      status = p.getStatus();
    } else {
      status = expected.getName() + " not found in proclist " + coordinator.getProcedureNames();
    }
    throw new HBaseSnapshotException("Snapshot " + ssString +  " had an error.  " + status, e,
      ProtobufUtil.createSnapshotDesc(expected));
  }

  // check to see if we are done
  if (handler.isFinished()) {
    LOG.debug("Snapshot '" + ssString + "' has completed, notifying client.");
    return true;
  } else if (LOG.isDebugEnabled()) {
    LOG.debug("Snapshoting '" + ssString + "' is still in progress!");
  }
  return false;
}
 

/**
 * Restore or Clone the specified snapshot
 * @param reqSnapshot
 * @param nonceKey unique identifier to prevent duplicated RPC
 * @throws IOException
 */
public long restoreOrCloneSnapshot(final SnapshotDescription reqSnapshot, final NonceKey nonceKey,
    final boolean restoreAcl) throws IOException {
  FileSystem fs = master.getMasterFileSystem().getFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(reqSnapshot, rootDir);

  // check if the snapshot exists
  if (!fs.exists(snapshotDir)) {
    LOG.error("A Snapshot named '" + reqSnapshot.getName() + "' does not exist.");
    throw new SnapshotDoesNotExistException(
      ProtobufUtil.createSnapshotDesc(reqSnapshot));
  }

  // Get snapshot info from file system. The reqSnapshot is a "fake" snapshotInfo with
  // just the snapshot "name" and table name to restore. It does not contains the "real" snapshot
  // information.
  SnapshotDescription snapshot = SnapshotDescriptionUtils.readSnapshotInfo(fs, snapshotDir);
  SnapshotManifest manifest = SnapshotManifest.open(master.getConfiguration(), fs,
      snapshotDir, snapshot);
  TableDescriptor snapshotTableDesc = manifest.getTableDescriptor();
  TableName tableName = TableName.valueOf(reqSnapshot.getTable());

  // sanity check the new table descriptor
  TableDescriptorChecker.sanityCheck(master.getConfiguration(), snapshotTableDesc);

  // stop tracking "abandoned" handlers
  cleanupSentinels();

  // Verify snapshot validity
  SnapshotReferenceUtil.verifySnapshot(master.getConfiguration(), fs, manifest);

  // Execute the restore/clone operation
  long procId;
  if (MetaTableAccessor.tableExists(master.getConnection(), tableName)) {
    procId = restoreSnapshot(reqSnapshot, tableName, snapshot, snapshotTableDesc, nonceKey,
      restoreAcl);
  } else {
    procId =
        cloneSnapshot(reqSnapshot, tableName, snapshot, snapshotTableDesc, nonceKey, restoreAcl);
  }
  return procId;
}
 

/** @return the snapshot descriptor */
public SnapshotDescription getSnapshotDescription() {
  return ProtobufUtil.createSnapshotDesc(this.snapshot);
}