Java Path.getParent方法代码示例

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Compare path component of the Path URI; e.g. if hdfs://a/b/c and /a/b/c, it will compare the
 * '/a/b/c' part. If you passed in 'hdfs://a/b/c and b/c, it would return true.  Does not consider
 * schema; i.e. if schemas different but path or subpath matches, the two will equate.
 * @param pathToSearch Path we will be trying to match.
 * @param pathTail
 * @return True if <code>pathTail</code> is tail on the path of <code>pathToSearch</code>
 */
public static boolean isMatchingTail(final Path pathToSearch, final Path pathTail) {
  if (pathToSearch.depth() != pathTail.depth()) return false;
  Path tailPath = pathTail;
  String tailName;
  Path toSearch = pathToSearch;
  String toSearchName;
  boolean result = false;
  do {
    tailName = tailPath.getName();
    if (tailName == null || tailName.length() <= 0) {
      result = true;
      break;
    }
    toSearchName = toSearch.getName();
    if (toSearchName == null || toSearchName.length() <= 0) break;
    // Move up a parent on each path for next go around.  Path doesn't let us go off the end.
    tailPath = tailPath.getParent();
    toSearch = toSearch.getParent();
  } while(tailName.equals(toSearchName));
  return result;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * @param permission Currently ignored.
 */
@Override
public boolean mkdirs(Path path, FsPermission permission) throws IOException {
  Path absolutePath = makeAbsolute(path);
  List<Path> paths = new ArrayList<Path>();
  do {
    paths.add(0, absolutePath);
    absolutePath = absolutePath.getParent();
  } while (absolutePath != null);
  
  boolean result = true;
  for (Path p : paths) {
    result &= mkdir(p);
  }
  return result;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Given a path to a directory within a local cache tree return the
 * root of the cache directory.
 * 
 * @param path the directory within a cache directory
 * @return the local cache directory root or null if not found
 */
public static Path getCacheDirectoryRoot(Path path) {
  while (path != null) {
    String name = path.getName();
    if (name.length() != 1) {
      return path;
    }
    int dirnum = DIRECTORIES_PER_LEVEL;
    try {
      dirnum = Integer.parseInt(name, DIRECTORIES_PER_LEVEL);
    } catch (NumberFormatException e) {
    }
    if (dirnum >= DIRECTORIES_PER_LEVEL) {
      return path;
    }
    path = path.getParent();
  }
  return path;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Create the output folder and optionally set ownership.
 */
private void createOutputPath(final Path path) throws IOException {
  if (filesUser == null && filesGroup == null) {
    outputFs.mkdirs(path);
  } else {
    Path parent = path.getParent();
    if (!outputFs.exists(parent) && !parent.isRoot()) {
      createOutputPath(parent);
    }
    outputFs.mkdirs(path);
    if (filesUser != null || filesGroup != null) {
      // override the owner when non-null user/group is specified
      outputFs.setOwner(path, filesUser, filesGroup);
    }
    if (filesMode > 0) {
      outputFs.setPermission(path, new FsPermission(filesMode));
    }
  }
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
protected void updateFile(Path outputPath, byte[] data, boolean
        makeUnradableByAdmin) throws Exception {
  Path newPath = new Path(outputPath.getParent(), outputPath.getName() + ".new");
  // use writeFileWithRetries to make sure .new file is created atomically
  writeFileWithRetries(newPath, data, makeUnradableByAdmin);
  replaceFile(newPath, outputPath);
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
@Override
public FSDataInputStream open(Path file, int bufferSize) throws IOException {
  FTPClient client = connect();
  Path workDir = new Path(client.printWorkingDirectory());
  Path absolute = makeAbsolute(workDir, file);
  FileStatus fileStat = getFileStatus(client, absolute);
  if (fileStat.isDirectory()) {
    disconnect(client);
    throw new FileNotFoundException("Path " + file + " is a directory.");
  }
  client.allocate(bufferSize);
  Path parent = absolute.getParent();
  // Change to parent directory on the
  // server. Only then can we read the
  // file
  // on the server by opening up an InputStream. As a side effect the working
  // directory on the server is changed to the parent directory of the file.
  // The FTP client connection is closed when close() is called on the
  // FSDataInputStream.
  client.changeWorkingDirectory(parent.toUri().getPath());
  InputStream is = client.retrieveFileStream(file.getName());
  FSDataInputStream fis = new FSDataInputStream(new FTPInputStream(is,
      client, statistics));
  if (!FTPReply.isPositivePreliminary(client.getReplyCode())) {
    // The ftpClient is an inconsistent state. Must close the stream
    // which in turn will logout and disconnect from FTP server
    fis.close();
    throw new IOException("Unable to open file: " + file + ", Aborting");
  }
  return fis;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Create the parent directories.
 * As an optimization, the entire hierarchy of parent
 * directories is <i>Not</i> polled. Instead
 * the tree is walked up from the last to the first,
 * creating directories until one that exists is found.
 *
 * This strategy means if a file is created in an existing directory,
 * one quick poll sufficies.
 *
 * There is a big assumption here: that all parent directories of an existing
 * directory also exists.
 * @param path path to create.
 * @param permission to apply to files
 * @return true if the operation was successful
 * @throws IOException on a problem
 */
@Override
public boolean mkdirs(Path path, FsPermission permission) throws IOException {
  if (LOG.isDebugEnabled()) {
    LOG.debug("SwiftFileSystem.mkdirs: " + path);
  }
  Path directory = makeAbsolute(path);

  //build a list of paths to create
  List<Path> paths = new ArrayList<Path>();
  while (shouldCreate(directory)) {
    //this directory needs creation, add to the list
    paths.add(0, directory);
    //now see if the parent needs to be created
    directory = directory.getParent();
  }

  //go through the list of directories to create
  for (Path p : paths) {
    if (isNotRoot(p)) {
      //perform a mkdir operation without any polling of
      //the far end first
      forceMkdir(p);
    }
  }

  //if an exception was not thrown, this operation is considered
  //a success
  return true;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Convenience method, so that we don't open a new connection when using this
 * method from within another method. Otherwise every API invocation incurs
 * the overhead of opening/closing a TCP connection.
 */
private FileStatus getFileStatus(FTPClient client, Path file)
    throws IOException {
  FileStatus fileStat = null;
  Path workDir = new Path(client.printWorkingDirectory());
  Path absolute = makeAbsolute(workDir, file);
  Path parentPath = absolute.getParent();
  if (parentPath == null) { // root dir
    long length = -1; // Length of root dir on server not known
    boolean isDir = true;
    int blockReplication = 1;
    long blockSize = DEFAULT_BLOCK_SIZE; // Block Size not known.
    long modTime = -1; // Modification time of root dir not known.
    Path root = new Path("/");
    return new FileStatus(length, isDir, blockReplication, blockSize,
        modTime, root.makeQualified(this));
  }
  String pathName = parentPath.toUri().getPath();
  FTPFile[] ftpFiles = client.listFiles(pathName);
  if (ftpFiles != null) {
    for (FTPFile ftpFile : ftpFiles) {
      if (ftpFile.getName().equals(file.getName())) { // file found in dir
        fileStat = getFileStatus(ftpFile, parentPath);
        break;
      }
    }
    if (fileStat == null) {
      throw new FileNotFoundException("File " + file + " does not exist.");
    }
  } else {
    throw new FileNotFoundException("File " + file + " does not exist.");
  }
  return fileStat;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
@Override
void prepare() throws Exception {
  final Path filePath = new Path(fileName);
  if (dfs.exists(filePath)) {
    dfs.delete(filePath, true);
  }
  final Path fileParent = filePath.getParent();
  if (!dfs.exists(fileParent)) {
    dfs.mkdirs(fileParent);
  }
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
@Override
public boolean mkdirs(Path f, FsPermission permission) throws IOException {
  Path absolutePath = makeAbsolute(f);
  List<Path> paths = new ArrayList<Path>();
  do {
    paths.add(0, absolutePath);
    absolutePath = absolutePath.getParent();
  } while (absolutePath != null);
  
  boolean result = true;
  for (Path path : paths) {
    result &= mkdir(path);
  }
  return result;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Check if any columns are dictionary encoded by looking up for .dict files
 * @param fs filesystem
 * @param selectionRoot root of table
 * @param batchSchema schema for this parquet table
 */
public static DictionaryEncodedColumns scanForDictionaryEncodedColumns(FileSystem fs, String selectionRoot, BatchSchema batchSchema) {
  try {
    Path root = new Path(selectionRoot);
    if (!fs.isDirectory(root)) {
      root = root.getParent();
    }
    long version = GlobalDictionaryBuilder.getDictionaryVersion(fs, root);
    if (version != -1) {
      final List<String> columns = Lists.newArrayList();
      final DictionaryEncodedColumns dictionaryEncodedColumns = new DictionaryEncodedColumns();
      root = GlobalDictionaryBuilder.getDictionaryVersionedRootPath(fs, root, version);
      for (Field field : batchSchema.getFields()) {
        final Path dictionaryFilePath = GlobalDictionaryBuilder.getDictionaryFile(fs, root, field.getName());
        if (dictionaryFilePath != null) {
          columns.add(field.getName());
        }
      }
      if (!columns.isEmpty()) {
        dictionaryEncodedColumns.setVersion(version);
        dictionaryEncodedColumns.setRootPath(root.toString());
        dictionaryEncodedColumns.setColumnsList(columns);
        return dictionaryEncodedColumns;
      }
    }
  } catch (UnsupportedOperationException e) { // class path based filesystem doesn't support listing
    if (!ClassPathFileSystem.SCHEME.equals(fs.getUri().getScheme())) {
      throw e;
    }
  } catch (IOException ioe) {
    logger.warn(format("Failed to scan directory %s for global dictionary", selectionRoot), ioe);
  }
  return null;
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
void verifyFile(final Path file, final Byte expectedPolicyId)
    throws Exception {
  final Path parent = file.getParent();
  DirectoryListing children = dfs.getClient().listPaths(
      parent.toString(), HdfsFileStatus.EMPTY_NAME, true);
  for (HdfsFileStatus child : children.getPartialListing()) {
    if (child.getLocalName().equals(file.getName())) {
      verifyFile(parent,  child, expectedPolicyId);
      return;
    }
  }
  Assert.fail("File " + file + " not found.");
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
/**
 * Create a local map output index file name on the same volume.
 */
public Path getOutputIndexFileForWriteInVolume(Path existing) {
  Path outputDir = new Path(existing.getParent(), JOB_OUTPUT_DIR);
  Path attemptOutputDir = new Path(outputDir,
      conf.get(JobContext.TASK_ATTEMPT_ID));
  return new Path(attemptOutputDir, MAP_OUTPUT_FILENAME_STRING +
                                    MAP_OUTPUT_INDEX_SUFFIX_STRING);
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
private void addParentDirectoriesRecursively(Path path) throws IOException {
    if (!path.isRoot()) {
        Path parent = path.getParent();
        IndexDirectory newEntry = new IndexDirectory(fs.getFileStatus(parent));
        newEntry.addChild(path.getName());
        index.addEntry(newEntry);
        addParentDirectoriesRecursively(parent);
    }
}
 

import org.apache.hadoop.fs.Path; //导入方法依赖的package包/类
private static void rewriteTableDescriptor(final FileSystem fs, final FileStatus status,
  final HTableDescriptor td)
throws IOException {
  Path tableInfoDir = status.getPath().getParent();
  Path tableDir = tableInfoDir.getParent();
  writeTableDescriptor(fs, td, tableDir, status);
}