Java Path.SEPARATOR_CHAR屬性代碼示例

private static int findLongestDirPrefix(String cwd, String path, boolean isDir) {
  // add the path separator to dirs to simplify finding the longest match
  if (!cwd.endsWith(Path.SEPARATOR)) {
    cwd += Path.SEPARATOR;
  }
  if (isDir && !path.endsWith(Path.SEPARATOR)) {
    path += Path.SEPARATOR;
  }

  // find longest directory prefix 
  int len = Math.min(cwd.length(), path.length());
  int lastSep = -1;
  for (int i=0; i < len; i++) {
    if (cwd.charAt(i) != path.charAt(i)) break;
    if (cwd.charAt(i) == Path.SEPARATOR_CHAR) lastSep = i;
  }
  return lastSep;
}
 

/**
 * Get the relative path name with respect to the root of the volume.
 * @param absolutePathName The absolute path name
 * @param volume Root of the volume.
 * @return null if the absolute path name is outside of the volume.
 */
private String getRelativePathName(String absolutePathName,
    String volume) {
  
  absolutePathName = normalizePath(absolutePathName);
  // Get the file names
  if (!absolutePathName.startsWith(volume)) {
    return null;
  }
  // Get rid of the volume prefix
  String fileName = absolutePathName.substring(volume.length());
  if (fileName.charAt(0) == Path.SEPARATOR_CHAR) {
    fileName = fileName.substring(1);
  }
  return fileName;
}
 

static private Map<String, Lease> findLeaseWithPrefixPath(
    String prefix, SortedMap<String, Lease> path2lease) {
  if (LOG.isDebugEnabled()) {
    LOG.debug(LeaseManager.class.getSimpleName() + ".findLease: prefix=" + prefix);
  }

  final Map<String, Lease> entries = new HashMap<String, Lease>();
  int srclen = prefix.length();
  
  // prefix may ended with '/'
  if (prefix.charAt(srclen - 1) == Path.SEPARATOR_CHAR) {
    srclen -= 1;
  }

  for(Map.Entry<String, Lease> entry : path2lease.tailMap(prefix).entrySet()) {
    final String p = entry.getKey();
    if (!p.startsWith(prefix)) {
      return entries;
    }
    if (p.length() == srclen || p.charAt(srclen) == Path.SEPARATOR_CHAR) {
      entries.put(entry.getKey(), entry.getValue());
    }
  }
  return entries;
}
 

private static void validateDestination(
    String src, String dst, INode srcInode)
    throws IOException {
  String error;
  if (srcInode.isSymlink() &&
      dst.equals(srcInode.asSymlink().getSymlinkString())) {
    throw new FileAlreadyExistsException("Cannot rename symlink " + src
        + " to its target " + dst);
  }
  // dst cannot be a directory or a file under src
  if (dst.startsWith(src)
      && dst.charAt(src.length()) == Path.SEPARATOR_CHAR) {
    error = "Rename destination " + dst
        + " is a directory or file under source " + src;
    NameNode.stateChangeLog.warn("DIR* FSDirectory.unprotectedRenameTo: "
        + error);
    throw new IOException(error);
  }
}
 

/**
 * This test creates some directories inside the toBeDeleted directory and
 * then start the asyncDiskService.
 * AsyncDiskService will create tasks to delete the content inside the
 * toBeDeleted directories.
 */
@Test
public void testMRAsyncDiskServiceStartupCleaning() throws Throwable {
  FileSystem localFileSystem = FileSystem.getLocal(new Configuration());
  String[] vols = new String[]{TEST_ROOT_DIR + "/0",
      TEST_ROOT_DIR + "/1"};

  String a = "a";
  String b = "b";
  String c = "b/c";
  String d = "d";
  
  // Create directories inside SUBDIR
  String suffix = Path.SEPARATOR_CHAR + MRAsyncDiskService.TOBEDELETED;
  File fa = new File(vols[0] + suffix, a);
  File fb = new File(vols[1] + suffix, b);
  File fc = new File(vols[1] + suffix, c);
  File fd = new File(vols[1] + suffix, d);
  
  // Create the directories
  fa.mkdirs();
  fb.mkdirs();
  fc.mkdirs();
  fd.mkdirs();

  assertTrue(fa.exists());
  assertTrue(fb.exists());
  assertTrue(fc.exists());
  assertTrue(fd.exists());
  
  // Create the asyncDiskService which will delete all contents inside SUBDIR
  MRAsyncDiskService service = new MRAsyncDiskService(
      localFileSystem, vols);
  
  // Make sure everything is cleaned up
  makeSureCleanedUp(vols, service);
}
 

public static String getSnapshotPath(String snapshottableDir,
    String snapshotRelativePath) {
  final StringBuilder b = new StringBuilder(snapshottableDir);
  if (b.charAt(b.length() - 1) != Path.SEPARATOR_CHAR) {
    b.append(Path.SEPARATOR);
  }
  return b.append(HdfsConstants.DOT_SNAPSHOT_DIR)
      .append(Path.SEPARATOR)
      .append(snapshotRelativePath)
      .toString();
}
 

@VisibleForTesting
String[] getPathElements(String path) {
  path = path.trim();
  if (path.charAt(0) != Path.SEPARATOR_CHAR) {
    throw new IllegalArgumentException("It must be an absolute path: " +
        path);
  }
  int numOfElements = StringUtils.countMatches(path, Path.SEPARATOR);
  if (path.length() > 1 && path.endsWith(Path.SEPARATOR)) {
    numOfElements--;
  }
  String[] pathElements = new String[numOfElements];
  int elementIdx = 0;
  int idx = 0;
  int found = path.indexOf(Path.SEPARATOR_CHAR, idx);
  while (found > -1) {
    if (found > idx) {
      pathElements[elementIdx++] = path.substring(idx, found);
    }
    idx = found + 1;
    found = path.indexOf(Path.SEPARATOR_CHAR, idx);
  }
  if (idx < path.length()) {
    pathElements[elementIdx] = path.substring(idx);
  }
  return pathElements;
}
 

static private boolean isAncestorPath(Path xp, Path yp) {
  final String x = xp.toString();
  final String y = yp.toString();
  if (!y.startsWith(x)) {
    return false;
  }
  final int len = x.length();
  return y.length() == len || y.charAt(len) == Path.SEPARATOR_CHAR;  
}
 

private String getCacheEntryFilePath(String checksum, String filename) {
  return SharedCacheUtil.getCacheEntryPath(this.cacheDepth,
      this.cacheRoot, checksum) + Path.SEPARATOR_CHAR + filename;
}
 

/**
 * Move the path name on one volume to a temporary location and then 
 * delete them.
 * 
 * This functions returns when the moves are done, but not necessarily all
 * deletions are done. This is usually good enough because applications 
 * won't see the path name under the old name anyway after the move. 
 * 
 * @param volume       The disk volume
 * @param pathName     The path name relative to volume root.
 * @throws IOException If the move failed 
 * @return   false     if the file is not found
 */
public boolean moveAndDeleteRelativePath(String volume, String pathName)
    throws IOException {
  
  volume = normalizePath(volume);
  
  // Move the file right now, so that it can be deleted later
  String newPathName = 
      format.format(new Date()) + "_" + uniqueId.getAndIncrement();
  newPathName = TOBEDELETED + Path.SEPARATOR_CHAR + newPathName;
  
  Path source = new Path(volume, pathName);
  Path target = new Path(volume, newPathName);
  try {
    if (!localFileSystem.rename(source, target)) {
      // If the source does not exists, return false.
      // This is necessary because rename can return false if the source  
      // does not exists.
      if (!localFileSystem.exists(source)) {
        return false;
      }
      // Try to recreate the parent directory just in case it gets deleted.
      if (!localFileSystem.mkdirs(new Path(volume, TOBEDELETED))) {
        throw new IOException("Cannot create " + TOBEDELETED + " under "
            + volume);
      }
      // Try rename again. If it fails, return false.
      if (!localFileSystem.rename(source, target)) {
        throw new IOException("Cannot rename " + source + " to "
            + target);
      }
    }
  } catch (FileNotFoundException e) {
    // Return false in case that the file is not found.  
    return false;
  }

  DeleteTask task = new DeleteTask(volume, pathName, newPathName);
  execute(volume, task);
  return true;
}