Java INode类代码示例

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public FileStatus[] listStatus(Path f) throws IOException {
  Path absolutePath = makeAbsolute(f);
  INode inode = store.retrieveINode(absolutePath);
  if (inode == null) {
    throw new FileNotFoundException("File " + f + " does not exist.");
  }
  if (inode.isFile()) {
    return new FileStatus[] {
        new S3FileStatus(f.makeQualified(this), inode)
    };
  }
  ArrayList<FileStatus> ret = new ArrayList<FileStatus>();
  for (Path p : store.listSubPaths(absolutePath)) {
    ret.add(getFileStatus(p.makeQualified(this)));
  }
  return ret.toArray(new FileStatus[0]);
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public FSDataOutputStream create(Path file, FsPermission permission,
                                 boolean overwrite, int bufferSize,
                                 short replication, long blockSize, Progressable progress)
    throws IOException {

  INode inode = store.retrieveINode(makeAbsolute(file));
  if (inode != null) {
    if (overwrite) {
      delete(file, true);
    } else {
      throw new IOException("File already exists: " + file);
    }
  } else {
    Path parent = file.getParent();
    if (parent != null) {
      if (!mkdirs(parent)) {
        throw new IOException("Mkdirs failed to create " + parent.toString());
      }
    }
  }
  return new FSDataOutputStream
      (new S3OutputStream(getConf(), store, makeAbsolute(file),
          blockSize, progress, bufferSize),
          statistics);
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
private boolean renameRecursive(Path src, Path dst) throws IOException {
  INode srcINode = store.retrieveINode(src);
  store.storeINode(dst, srcINode);
  store.deleteINode(src);
  if (srcINode.isDirectory()) {
    for (Path oldSrc : store.listDeepSubPaths(src)) {
      INode inode = store.retrieveINode(oldSrc);
      if (inode == null) {
        return false;
      }
      String oldSrcPath = oldSrc.toUri().getPath();
      String srcPath = src.toUri().getPath();
      String dstPath = dst.toUri().getPath();
      Path newDst = new Path(oldSrcPath.replaceFirst(srcPath, dstPath));
      store.storeINode(newDst, inode);
      store.deleteINode(oldSrc);
    }
  }
  return true;
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public boolean isFile(Path path) throws IOException {
  INode inode = store.retrieveINode(makeAbsolute(path));
  if (inode == null) {
    return false;
  }
  return inode.isFile();
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
private INode checkFile(Path path) throws IOException {
  INode inode = store.retrieveINode(makeAbsolute(path));
  if (inode == null) {
    throw new IOException("No such file.");
  }
  if (inode.isDirectory()) {
    throw new IOException("Path " + path + " is a directory.");
  }
  return inode;
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public boolean rename(Path src, Path dst) throws IOException {
  Path absoluteSrc = makeAbsolute(src);
  INode srcINode = store.retrieveINode(absoluteSrc);
  if (srcINode == null) {
    // src path doesn't exist
    return false;
  }
  Path absoluteDst = makeAbsolute(dst);
  INode dstINode = store.retrieveINode(absoluteDst);
  if (dstINode != null && dstINode.isDirectory()) {
    absoluteDst = new Path(absoluteDst, absoluteSrc.getName());
    dstINode = store.retrieveINode(absoluteDst);
  }
  if (dstINode != null) {
    // dst path already exists - can't overwrite
    return false;
  }
  Path dstParent = absoluteDst.getParent();
  if (dstParent != null) {
    INode dstParentINode = store.retrieveINode(dstParent);
    if (dstParentINode == null || dstParentINode.isFile()) {
      // dst parent doesn't exist or is a file
      return false;
    }
  }
  return renameRecursive(absoluteSrc, absoluteDst);
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public boolean delete(Path path, boolean recursive) throws IOException {
  Path absolutePath = makeAbsolute(path);
  INode inode = store.retrieveINode(absolutePath);
  if (inode == null) {
    return false;
  }
  if (inode.isFile()) {
    store.deleteINode(absolutePath);
    for (Block block: inode.getBlocks()) {
      store.deleteBlock(block);
    }
  } else {
    FileStatus[] contents = null;
    try {
      contents = listStatus(absolutePath);
    } catch(FileNotFoundException fnfe) {
      return false;
    }

    if ((contents.length !=0) && (!recursive)) {
      throw new IOException("Directory " + path.toString()
          + " is not empty.");
    }
    for (FileStatus p:contents) {
      if (!delete(p.getPath(), recursive)) {
        return false;
      }
    }
    store.deleteINode(absolutePath);
  }
  return true;
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
/**
 * FileStatus for S3 file systems.
 */
@Override
public FileStatus getFileStatus(Path f)  throws IOException {
  INode inode = store.retrieveINode(makeAbsolute(f));
  if (inode == null) {
    throw new FileNotFoundException(f + ": No such file or directory.");
  }
  return new S3FileStatus(f.makeQualified(this), inode);
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
private boolean mkdir(Path path) throws IOException {
  Path absolutePath = makeAbsolute(path);
  INode inode = store.retrieveINode(absolutePath);
  if (inode == null) {
    store.storeINode(absolutePath, INode.DIRECTORY_INODE);
  } else if (inode.isFile()) {
    throw new IOException(String.format(
        "Can't make directory for path %s since it is a file.",
        absolutePath));
  }
  return true;
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
private static long findLength(INode inode) {
  if (!inode.isDirectory()) {
    long length = 0L;
    for (Block block : inode.getBlocks()) {
      length += block.getLength();
    }
    return length;
  }
  return 0;
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
private synchronized void endBlock() throws IOException {
  //
  // Done with local copy
  //
  backupStream.close();

  //
  // Send it to S3
  //
  // TODO: Use passed in Progressable to report progress.
  nextBlockOutputStream();
  store.storeBlock(nextBlock, backupFile);
  Block[] arr = new Block[blocks.size()];
  arr = blocks.toArray(arr);
  store.storeINode(path, new INode(INode.FILE_TYPES[1], arr));

  //
  // Delete local backup, start new one
  //
  boolean b = backupFile.delete();
  if (!b) {
    LOG.warn("Ignoring failed delete");
  }
  backupFile = newBackupFile();
  backupStream = new FileOutputStream(backupFile);
  bytesWrittenToBlock = 0;
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
S3FileStatus(Path f, INode inode) throws IOException {
  super(findLength(inode), inode.isDirectory(), 1,
      findBlocksize(inode), 0, f);
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
private static long findBlocksize(INode inode) {
  final Block[] ret = inode.getBlocks();
  return ret == null ? 0L : ret[0].getLength();
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public INode retrieveINode(Path path) throws IOException {
  return inodes.get(normalize(path));
}
 

import org.apache.hadoop.fs.s3.INode; //导入依赖的package包/类
@Override
public void storeINode(Path path, INode inode) throws IOException {
  inodes.put(normalize(path), inode);
}