Java FSTableDescriptors.getTableDescriptor方法代码示例

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
@Override
public Void call() throws Exception {
  LOG.debug("Running table info copy.");
  this.rethrowException();
  LOG.debug("Attempting to copy table info for snapshot:"
      + SnapshotDescriptionUtils.toString(this.snapshot));
  // get the HTable descriptor
  HTableDescriptor orig = FSTableDescriptors.getTableDescriptor(fs, rootDir,
    Bytes.toBytes(this.snapshot.getTable()));
  this.rethrowException();
  // write a copy of descriptor to the snapshot directory
  Path snapshotDir = SnapshotDescriptionUtils.getWorkingSnapshotDir(snapshot, rootDir);
  FSTableDescriptors.createTableDescriptorForTableDirectory(fs, snapshotDir, orig, false);
  LOG.debug("Finished copying tableinfo.");
  return null;
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
/**
 * Load snapshot info and table descriptor for the specified snapshot
 * @param snapshotName name of the snapshot to load
 * @return false if snapshot is not found
 */
private boolean loadSnapshotInfo(final String snapshotName) throws IOException {
  snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshotName, rootDir);
  if (!fs.exists(snapshotDir)) {
    LOG.warn("Snapshot '" + snapshotName + "' not found in: " + snapshotDir);
    return false;
  }

  snapshotDesc = SnapshotDescriptionUtils.readSnapshotInfo(fs, snapshotDir);
  snapshotTableDesc = FSTableDescriptors.getTableDescriptor(fs, snapshotDir);
  return true;
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
private void compactTable(final Path tableDir, final boolean compactOnce, final boolean major)
    throws IOException {
  HTableDescriptor htd = FSTableDescriptors.getTableDescriptor(fs, tableDir);
  LOG.info("Compact table=" + htd.getNameAsString());
  for (Path regionDir: FSUtils.getRegionDirs(fs, tableDir)) {
    compactRegion(htd, regionDir, compactOnce, major);
  }
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
private void verifyTableDescriptor(final byte[] tableName, final byte[]... families)
    throws IOException {
  HBaseAdmin admin = TEST_UTIL.getHBaseAdmin();

  // Verify descriptor from master
  HTableDescriptor htd = admin.getTableDescriptor(tableName);
  verifyTableDescriptor(htd, tableName, families);

  // Verify descriptor from HDFS
  MasterFileSystem mfs = TEST_UTIL.getMiniHBaseCluster().getMaster().getMasterFileSystem();
  Path tableDir = HTableDescriptor.getTableDir(mfs.getRootDir(), tableName);
  htd = FSTableDescriptors.getTableDescriptor(mfs.getFileSystem(), tableDir);
  verifyTableDescriptor(htd, tableName, families);
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
private void compactTable(final Path tableDir, final boolean compactOnce)
    throws IOException {
  HTableDescriptor htd = FSTableDescriptors.getTableDescriptor(fs, tableDir);
  LOG.info("Compact table=" + htd.getNameAsString());
  for (Path regionDir: FSUtils.getRegionDirs(fs, tableDir)) {
    compactRegion(htd, regionDir, compactOnce);
  }
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
/**
 * Confirm that the snapshot contains references to all the files that should be in the snapshot
 */
public static void confirmSnapshotValid(SnapshotDescription snapshotDescriptor,
    byte[] tableName, byte[] testFamily, Path rootDir, HBaseAdmin admin, FileSystem fs,
    boolean requireLogs, Path logsDir, Set<String> snapshotServers) throws IOException {
  Path snapshotDir = SnapshotDescriptionUtils
      .getCompletedSnapshotDir(snapshotDescriptor, rootDir);
  assertTrue(fs.exists(snapshotDir));
  Path snapshotinfo = new Path(snapshotDir, SnapshotDescriptionUtils.SNAPSHOTINFO_FILE);
  assertTrue(fs.exists(snapshotinfo));
  // check the logs dir
  if (requireLogs) {
    TakeSnapshotUtils.verifyAllLogsGotReferenced(fs, logsDir, snapshotServers,
      snapshotDescriptor, new Path(snapshotDir, HConstants.HREGION_LOGDIR_NAME));
  }
  // check the table info
  HTableDescriptor desc = FSTableDescriptors.getTableDescriptor(fs, rootDir, tableName);
  HTableDescriptor snapshotDesc = FSTableDescriptors.getTableDescriptor(fs, snapshotDir);
  assertEquals(desc, snapshotDesc);

  // check the region snapshot for all the regions
  List<HRegionInfo> regions = admin.getTableRegions(tableName);
  for (HRegionInfo info : regions) {
    String regionName = info.getEncodedName();
    Path regionDir = new Path(snapshotDir, regionName);
    HRegionInfo snapshotRegionInfo = HRegion.loadDotRegionInfoFileContent(fs, regionDir);
    assertEquals(info, snapshotRegionInfo);
    // check to make sure we have the family
    Path familyDir = new Path(regionDir, Bytes.toString(testFamily));
    assertTrue("Expected to find: " + familyDir + ", but it doesn't exist", fs.exists(familyDir));
    // make sure we have some files references
    assertTrue(fs.listStatus(familyDir).length > 0);
  }
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
/**
 * Restore the specified snapshot
 * @param reqSnapshot
 * @throws IOException
 */
public void restoreSnapshot(SnapshotDescription reqSnapshot) throws IOException {
  FileSystem fs = master.getMasterFileSystem().getFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(reqSnapshot, rootDir);
  MasterCoprocessorHost cpHost = master.getCoprocessorHost();

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

  // read snapshot information
  SnapshotDescription fsSnapshot = SnapshotDescriptionUtils.readSnapshotInfo(fs, snapshotDir);
  HTableDescriptor snapshotTableDesc = FSTableDescriptors.getTableDescriptor(fs, snapshotDir);
  String tableName = reqSnapshot.getTable();

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

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

  // Execute the restore/clone operation
  if (MetaReader.tableExists(master.getCatalogTracker(), tableName)) {
    if (master.getAssignmentManager().getZKTable().isEnabledTable(fsSnapshot.getTable())) {
      throw new UnsupportedOperationException("Table '" +
        fsSnapshot.getTable() + "' must be disabled in order to perform a restore operation.");
    }

    // call coproc pre hook
    if (cpHost != null) {
      cpHost.preRestoreSnapshot(reqSnapshot, snapshotTableDesc);
    }
    restoreSnapshot(fsSnapshot, snapshotTableDesc);
    LOG.info("Restore snapshot=" + fsSnapshot.getName() + " as table=" + tableName);

    if (cpHost != null) {
      cpHost.postRestoreSnapshot(reqSnapshot, snapshotTableDesc);
    }
  } else {
    HTableDescriptor htd = RestoreSnapshotHelper.cloneTableSchema(snapshotTableDesc,
                                                       Bytes.toBytes(tableName));
    if (cpHost != null) {
      cpHost.preCloneSnapshot(reqSnapshot, htd);
    }
    cloneSnapshot(fsSnapshot, htd);
    LOG.info("Clone snapshot=" + fsSnapshot.getName() + " as table=" + tableName);

    if (cpHost != null) {
      cpHost.postCloneSnapshot(reqSnapshot, htd);
    }
  }
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
/**
 * Basic end-to-end test of simple-flush-based snapshots
 */
@Test
public void testFlushCreateListDestroy() throws Exception {
  LOG.debug("------- Starting Snapshot test -------------");
  HBaseAdmin admin = UTIL.getHBaseAdmin();
  // make sure we don't fail on listing snapshots
  SnapshotTestingUtils.assertNoSnapshots(admin);
  // load the table so we have some data
  UTIL.loadTable(new HTable(UTIL.getConfiguration(), TABLE_NAME), TEST_FAM);
  // and wait until everything stabilizes
  waitForTableToBeOnline(TABLE_NAME);

  String snapshotName = "flushSnapshotCreateListDestroy";
  // test creating the snapshot
  admin.snapshot(snapshotName, STRING_TABLE_NAME, SnapshotDescription.Type.FLUSH);
  logFSTree(new Path(UTIL.getConfiguration().get(HConstants.HBASE_DIR)));

  // make sure we only have 1 matching snapshot
  List<SnapshotDescription> snapshots = SnapshotTestingUtils.assertOneSnapshotThatMatches(admin,
    snapshotName, STRING_TABLE_NAME);

  // check the directory structure
  FileSystem fs = UTIL.getHBaseCluster().getMaster().getMasterFileSystem().getFileSystem();
  Path rootDir = UTIL.getHBaseCluster().getMaster().getMasterFileSystem().getRootDir();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(snapshots.get(0), rootDir);
  assertTrue(fs.exists(snapshotDir));
  FSUtils.logFileSystemState(UTIL.getTestFileSystem(), snapshotDir, LOG);
  Path snapshotinfo = new Path(snapshotDir, SnapshotDescriptionUtils.SNAPSHOTINFO_FILE);
  assertTrue(fs.exists(snapshotinfo));

  // check the table info
  HTableDescriptor desc = FSTableDescriptors.getTableDescriptor(fs, rootDir, TABLE_NAME);
  HTableDescriptor snapshotDesc = FSTableDescriptors.getTableDescriptor(fs,
    SnapshotDescriptionUtils.getSnapshotsDir(rootDir), Bytes.toBytes(snapshotName));
  assertEquals(desc, snapshotDesc);

  // check the region snapshot for all the regions
  List<HRegionInfo> regions = admin.getTableRegions(TABLE_NAME);
  for (HRegionInfo info : regions) {
    String regionName = info.getEncodedName();
    Path regionDir = new Path(snapshotDir, regionName);
    HRegionInfo snapshotRegionInfo = HRegion.loadDotRegionInfoFileContent(fs, regionDir);
    assertEquals(info, snapshotRegionInfo);
    // check to make sure we have the family
    Path familyDir = new Path(regionDir, Bytes.toString(TEST_FAM));
    assertTrue(fs.exists(familyDir));
    // make sure we have some file references
    assertTrue(fs.listStatus(familyDir).length > 0);
  }

  // test that we can delete the snapshot
  admin.deleteSnapshot(snapshotName);
  FSUtils.logFileSystemState(UTIL.getTestFileSystem(),
    FSUtils.getRootDir(UTIL.getConfiguration()), LOG);

  // make sure we don't have any snapshots
  SnapshotTestingUtils.assertNoSnapshots(admin);
  LOG.debug("------- Flush-Snapshot Create List Destroy-------------");
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
/**
 * Restore the specified snapshot
 * @param reqSnapshot
 * @throws IOException
 */
public void restoreSnapshot(SnapshotDescription reqSnapshot) throws IOException {
  FileSystem fs = master.getMasterFileSystem().getFileSystem();
  Path snapshotDir = SnapshotDescriptionUtils.getCompletedSnapshotDir(reqSnapshot, rootDir);
  MasterCoprocessorHost cpHost = master.getCoprocessorHost();

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

  // read snapshot information
  SnapshotDescription fsSnapshot = SnapshotDescriptionUtils.readSnapshotInfo(fs, snapshotDir);
  HTableDescriptor snapshotTableDesc = FSTableDescriptors.getTableDescriptor(fs, snapshotDir);
  String tableName = reqSnapshot.getTable();

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

  // Execute the restore/clone operation
  if (MetaReader.tableExists(master.getCatalogTracker(), tableName)) {
    if (master.getAssignmentManager().getZKTable().isEnabledTable(fsSnapshot.getTable())) {
      throw new UnsupportedOperationException("Table '" +
        fsSnapshot.getTable() + "' must be disabled in order to perform a restore operation.");
    }

    // call coproc pre hook
    if (cpHost != null) {
      cpHost.preRestoreSnapshot(reqSnapshot, snapshotTableDesc);
    }
    restoreSnapshot(fsSnapshot, snapshotTableDesc);
    LOG.info("Restore snapshot=" + fsSnapshot.getName() + " as table=" + tableName);

    if (cpHost != null) {
      cpHost.postRestoreSnapshot(reqSnapshot, snapshotTableDesc);
    }
  } else {
    HTableDescriptor htd = RestoreSnapshotHelper.cloneTableSchema(snapshotTableDesc,
                                                       Bytes.toBytes(tableName));
    if (cpHost != null) {
      cpHost.preCloneSnapshot(reqSnapshot, htd);
    }
    cloneSnapshot(fsSnapshot, htd);
    LOG.info("Clone snapshot=" + fsSnapshot.getName() + " as table=" + tableName);

    if (cpHost != null) {
      cpHost.postCloneSnapshot(reqSnapshot, htd);
    }
  }
}
 

import org.apache.hadoop.hbase.util.FSTableDescriptors; //导入方法依赖的package包/类
/**
 * Check that the table descriptor for the snapshot is a valid table descriptor
 * @param snapshotDir snapshot directory to check
 */
private void verifyTableInfo(Path snapshotDir) throws IOException {
  FSTableDescriptors.getTableDescriptor(fs, snapshotDir);
}