Java HConstants.HBASE_TEMP_DIRECTORY屬性代碼示例

public MasterFileSystem(Server master, MasterServices services)
throws IOException {
  this.conf = master.getConfiguration();
  this.master = master;
  this.services = services;
  // Set filesystem to be that of this.rootdir else we get complaints about
  // mismatched filesystems if hbase.rootdir is hdfs and fs.defaultFS is
  // default localfs.  Presumption is that rootdir is fully-qualified before
  // we get to here with appropriate fs scheme.
  this.rootdir = FSUtils.getRootDir(conf);
  this.tempdir = new Path(this.rootdir, HConstants.HBASE_TEMP_DIRECTORY);
  // Cover both bases, the old way of setting default fs and the new.
  // We're supposed to run on 0.20 and 0.21 anyways.
  this.fs = this.rootdir.getFileSystem(conf);
  FSUtils.setFsDefault(conf, new Path(this.fs.getUri()));
  // make sure the fs has the same conf
  fs.setConf(conf);
  // setup the filesystem variable
  // set up the archived logs path
  this.oldLogDir = createInitialFileSystemLayout();
  HFileSystem.addLocationsOrderInterceptor(conf);
  this.splitLogManager =
      new SplitLogManager(master, master.getConfiguration(), master, services,
          master.getServerName());
  this.distributedLogReplay = this.splitLogManager.isLogReplaying();
}
 

@Override
public FSDataOutputStream call() throws IOException {
  try {
    FileSystem fs = FSUtils.getCurrentFileSystem(getConf());
    FsPermission defaultPerms = FSUtils.getFilePermissions(fs, getConf(),
        HConstants.DATA_FILE_UMASK_KEY);
    Path tmpDir = new Path(FSUtils.getRootDir(getConf()), HConstants.HBASE_TEMP_DIRECTORY);
    fs.mkdirs(tmpDir);
    HBCK_LOCK_PATH = new Path(tmpDir, HBCK_LOCK_FILE);
    final FSDataOutputStream out = createFileWithRetries(fs, HBCK_LOCK_PATH, defaultPerms);
    out.writeBytes(InetAddress.getLocalHost().toString());
    out.flush();
    return out;
  } catch(RemoteException e) {
    if(AlreadyBeingCreatedException.class.getName().equals(e.getClassName())){
      return null;
    } else {
      throw e;
    }
  }
}
 

public void init() throws IOException {
  this.rootDir = FSUtils.getRootDir(conf);
  FSUtils.setFsDefault(getConf(), rootDir);
  this.fs = FileSystem.get(conf);
  Path tmpDataDir = new Path(rootDir, TMP_DATA_DIR);
  sysNsDir = new Path(tmpDataDir, NamespaceDescriptor.SYSTEM_NAMESPACE_NAME_STR);
  defNsDir = new Path(tmpDataDir, NamespaceDescriptor.DEFAULT_NAMESPACE_NAME_STR);
  baseDirs = new Path[]{rootDir,
      new Path(rootDir, HConstants.HFILE_ARCHIVE_DIRECTORY),
      new Path(rootDir, HConstants.HBASE_TEMP_DIRECTORY)};
  backupDir = new Path(rootDir, HConstants.MIGRATION_NAME);
}
 

/**
 * Sets version of file system
 *
 * @param fs filesystem object
 * @param rootdir hbase root directory
 * @param version version to set
 * @param wait time to wait for retry
 * @param retries number of times to retry before throwing an IOException
 * @throws IOException e
 */
public static void setVersion(FileSystem fs, Path rootdir, String version,
    int wait, int retries) throws IOException {
  Path versionFile = new Path(rootdir, HConstants.VERSION_FILE_NAME);
  Path tempVersionFile = new Path(rootdir, HConstants.HBASE_TEMP_DIRECTORY + Path.SEPARATOR +
    HConstants.VERSION_FILE_NAME);
  while (true) {
    try {
      // Write the version to a temporary file
      FSDataOutputStream s = fs.create(tempVersionFile);
      try {
        s.write(toVersionByteArray(version));
        s.close();
        s = null;
        // Move the temp version file to its normal location. Returns false
        // if the rename failed. Throw an IOE in that case.
        if (!fs.rename(tempVersionFile, versionFile)) {
          throw new IOException("Unable to move temp version file to " + versionFile);
        }
      } finally {
        // Cleaning up the temporary if the rename failed would be trying
        // too hard. We'll unconditionally create it again the next time
        // through anyway, files are overwritten by default by create().

        // Attempt to close the stream on the way out if it is still open.
        try {
          if (s != null) s.close();
        } catch (IOException ignore) { }
      }
      LOG.info("Created version file at " + rootdir.toString() + " with version=" + version);
      return;
    } catch (IOException e) {
      if (retries > 0) {
        LOG.debug("Unable to create version file at " + rootdir.toString() + ", retrying", e);
        fs.delete(versionFile, false);
        try {
          if (wait > 0) {
            Thread.sleep(wait);
          }
        } catch (InterruptedException ie) {
          throw (InterruptedIOException)new InterruptedIOException().initCause(ie);
        }
        retries--;
      } else {
        throw e;
      }
    }
  }
}
 

/**
 * @param rootDir Path to the root directory where hbase files are stored
 * @param archiveDir Path to the hbase archive directory
 * @param hFileLinkPattern The path of the HFile Link.
 */
public final static HFileLink buildFromHFileLinkPattern(final Path rootDir,
                                                        final Path archiveDir,
                                                        final Path hFileLinkPattern) {
  Path hfilePath = getHFileLinkPatternRelativePath(hFileLinkPattern);
  Path tempPath = new Path(new Path(rootDir, HConstants.HBASE_TEMP_DIRECTORY), hfilePath);
  Path originPath = new Path(rootDir, hfilePath);
  Path archivePath = new Path(archiveDir, hfilePath);
  return new HFileLink(originPath, tempPath, archivePath);
}
 

/**
 * Writes a new unique identifier for this cluster to the "hbase.id" file
 * in the HBase root directory
 * @param fs the root directory FileSystem
 * @param rootdir the path to the HBase root directory
 * @param clusterId the unique identifier to store
 * @param wait how long (in milliseconds) to wait between retries
 * @throws IOException if writing to the FileSystem fails and no wait value
 */
public static void setClusterId(FileSystem fs, Path rootdir, ClusterId clusterId,
    int wait) throws IOException {
  while (true) {
    try {
      Path idFile = new Path(rootdir, HConstants.CLUSTER_ID_FILE_NAME);
      Path tempIdFile = new Path(rootdir, HConstants.HBASE_TEMP_DIRECTORY +
        Path.SEPARATOR + HConstants.CLUSTER_ID_FILE_NAME);
      // Write the id file to a temporary location
      FSDataOutputStream s = fs.create(tempIdFile);
      try {
        s.write(clusterId.toByteArray());
        s.close();
        s = null;
        // Move the temporary file to its normal location. Throw an IOE if
        // the rename failed
        if (!fs.rename(tempIdFile, idFile)) {
          throw new IOException("Unable to move temp version file to " + idFile);
        }
      } finally {
        // Attempt to close the stream if still open on the way out
        try {
          if (s != null) s.close();
        } catch (IOException ignore) { }
      }
      if (LOG.isDebugEnabled()) {
        LOG.debug("Created cluster ID file at " + idFile.toString() + " with ID: " + clusterId);
      }
      return;
    } catch (IOException ioe) {
      if (wait > 0) {
        LOG.warn("Unable to create cluster ID file in " + rootdir.toString() +
            ", retrying in " + wait + "msec: " + StringUtils.stringifyException(ioe));
        try {
          Thread.sleep(wait);
        } catch (InterruptedException e) {
          throw (InterruptedIOException)new InterruptedIOException().initCause(e);
        }
      } else {
        throw ioe;
      }
    }
  }
}