Java ImageElement类代码示例

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process CacheManager state from the fsimage.
 */
private void processCacheManagerState(DataInputStream in, ImageVisitor v)
    throws IOException {
  v.visit(ImageElement.CACHE_NEXT_ENTRY_ID, in.readLong());
  final int numPools = in.readInt();
  for (int i=0; i<numPools; i++) {
    v.visit(ImageElement.CACHE_POOL_NAME, Text.readString(in));
    processCachePoolPermission(in, v);
    v.visit(ImageElement.CACHE_POOL_WEIGHT, in.readInt());
  }
  final int numEntries = in.readInt();
  for (int i=0; i<numEntries; i++) {
    v.visit(ImageElement.CACHE_ENTRY_PATH, Text.readString(in));
    v.visit(ImageElement.CACHE_ENTRY_REPLICATION, in.readShort());
    v.visit(ImageElement.CACHE_ENTRY_POOL_NAME, Text.readString(in));
  }
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process the INode records stored in the fsimage.
 *
 * @param in Datastream to process
 * @param v Visitor to walk over INodes
 * @param numInodes Number of INodes stored in file
 * @param skipBlocks Process all the blocks within the INode?
 * @param supportSnapshot Whether or not the imageVersion supports snapshot
 * @throws VisitException
 * @throws IOException
 */
private void processINodes(DataInputStream in, ImageVisitor v,
    long numInodes, boolean skipBlocks, boolean supportSnapshot)
    throws IOException {
  v.visitEnclosingElement(ImageElement.INODES,
      ImageElement.NUM_INODES, numInodes);
  
  if (NameNodeLayoutVersion.supports(Feature.FSIMAGE_NAME_OPTIMIZATION, imageVersion)) {
    if (!supportSnapshot) {
      processLocalNameINodes(in, v, numInodes, skipBlocks);
    } else {
      processLocalNameINodesWithSnapshot(in, v, skipBlocks);
    }
  } else { // full path name
    processFullNameINodes(in, v, numInodes, skipBlocks);
  }

  
  v.leaveEnclosingElement(); // INodes
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process snapshots of a snapshottable directory
 */
private void processSnapshots(DataInputStream in, ImageVisitor v,
    String rootName) throws IOException {
  final int numSnapshots = in.readInt();
  if (numSnapshots >= 0) {
    v.visitEnclosingElement(ImageElement.SNAPSHOTS,
        ImageElement.NUM_SNAPSHOTS, numSnapshots);
    for (int i = 0; i < numSnapshots; i++) {
      // process snapshot
      v.visitEnclosingElement(ImageElement.SNAPSHOT);
      v.visit(ImageElement.SNAPSHOT_ID, in.readInt());
      v.leaveEnclosingElement();
    }
    v.visit(ImageElement.SNAPSHOT_QUOTA, in.readInt());
    v.leaveEnclosingElement();
  }
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
private void processFileDiff(DataInputStream in, ImageVisitor v,
    String currentINodeName) throws IOException {
  int snapshotId = in.readInt();
  v.visitEnclosingElement(ImageElement.SNAPSHOT_FILE_DIFF,
      ImageElement.SNAPSHOT_DIFF_SNAPSHOTID, snapshotId);
  v.visit(ImageElement.SNAPSHOT_FILE_SIZE, in.readLong());
  if (in.readBoolean()) {
    v.visitEnclosingElement(ImageElement.SNAPSHOT_INODE_FILE_ATTRIBUTES);
    if (NameNodeLayoutVersion.supports(Feature.OPTIMIZE_SNAPSHOT_INODES, imageVersion)) {
      processINodeFileAttributes(in, v, currentINodeName);
    } else {
      processINode(in, v, true, currentINodeName, true);
    }
    v.leaveEnclosingElement();
  }
  v.leaveEnclosingElement();
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process the INode records stored in the fsimage.
 *
 * @param in Datastream to process
 * @param v Visitor to walk over INodes
 * @param numInodes Number of INodes stored in file
 * @param skipBlocks Process all the blocks within the INode?
 * @param supportSnapshot Whether or not the imageVersion supports snapshot
 * @throws VisitException
 * @throws IOException
 */
private void processINodes(DataInputStream in, ImageVisitor v,
    long numInodes, boolean skipBlocks, boolean supportSnapshot)
    throws IOException {
  v.visitEnclosingElement(ImageElement.INODES,
      ImageElement.NUM_INODES, numInodes);
  
  if (LayoutVersion.supports(Feature.FSIMAGE_NAME_OPTIMIZATION, imageVersion)) {
    if (!supportSnapshot) {
      processLocalNameINodes(in, v, numInodes, skipBlocks);
    } else {
      processLocalNameINodesWithSnapshot(in, v, skipBlocks);
    }
  } else { // full path name
    processFullNameINodes(in, v, numInodes, skipBlocks);
  }

  
  v.leaveEnclosingElement(); // INodes
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
private void processFileDiff(DataInputStream in, ImageVisitor v,
    String currentINodeName) throws IOException {
  int snapshotId = in.readInt();
  v.visitEnclosingElement(ImageElement.SNAPSHOT_FILE_DIFF,
      ImageElement.SNAPSHOT_DIFF_SNAPSHOTID, snapshotId);
  v.visit(ImageElement.SNAPSHOT_FILE_SIZE, in.readLong());
  if (in.readBoolean()) {
    v.visitEnclosingElement(ImageElement.SNAPSHOT_INODE_FILE_ATTRIBUTES);
    if (LayoutVersion.supports(Feature.OPTIMIZE_SNAPSHOT_INODES, imageVersion)) {
      processINodeFileAttributes(in, v, currentINodeName);
    } else {
      processINode(in, v, true, currentINodeName, true);
    }
    v.leaveEnclosingElement();
  }
  v.leaveEnclosingElement();
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process the INode records stored in the fsimage.
 *
 * @param in Datastream to process
 * @param v Visitor to walk over INodes
 * @param numInodes Number of INodes stored in file
 * @param skipBlocks Process all the blocks within the INode?
 * @param supportSnapshot Whether or not the imageVersion supports snapshot
 * @throws VisitException
 * @throws IOException
 */
private void processINodes(DataInputStream in, ImageVisitor v,
    long numInodes, boolean skipBlocks, boolean supportSnapshot)
    throws IOException {
  v.visitEnclosingElement(ImageElement.INODES,
      ImageElement.NUM_INODES, numInodes);
  
  if (NameNodeLayoutVersion.supports(
      LayoutVersion.Feature.FSIMAGE_NAME_OPTIMIZATION, imageVersion)) {
    if (!supportSnapshot) {
      processLocalNameINodes(in, v, numInodes, skipBlocks);
    } else {
      processLocalNameINodesWithSnapshot(in, v, skipBlocks);
    }
  } else { // full path name
    processFullNameINodes(in, v, numInodes, skipBlocks);
  }

  
  v.leaveEnclosingElement(); // INodes
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
private void processFileDiff(DataInputStream in, ImageVisitor v,
    String currentINodeName) throws IOException {
  int snapshotId = in.readInt();
  v.visitEnclosingElement(ImageElement.SNAPSHOT_FILE_DIFF,
      ImageElement.SNAPSHOT_DIFF_SNAPSHOTID, snapshotId);
  v.visit(ImageElement.SNAPSHOT_FILE_SIZE, in.readLong());
  if (in.readBoolean()) {
    v.visitEnclosingElement(ImageElement.SNAPSHOT_INODE_FILE_ATTRIBUTES);
    if (NameNodeLayoutVersion.supports(
        LayoutVersion.Feature.OPTIMIZE_SNAPSHOT_INODES, imageVersion)) {
      processINodeFileAttributes(in, v, currentINodeName);
    } else {
      processINode(in, v, true, currentINodeName, true);
    }
    v.leaveEnclosingElement();
  }
  v.leaveEnclosingElement();
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process the Delegation Token related section in fsimage.
 * 
 * @param in DataInputStream to process
 * @param v Visitor to walk over records
 */
private void processDelegationTokens(DataInputStream in, ImageVisitor v)
    throws IOException {
  v.visit(ImageElement.CURRENT_DELEGATION_KEY_ID, in.readInt());
  int numDKeys = in.readInt();
  v.visitEnclosingElement(ImageElement.DELEGATION_KEYS,
      ImageElement.NUM_DELEGATION_KEYS, numDKeys);
  for(int i =0; i < numDKeys; i++) {
    DelegationKey key = new DelegationKey();
    key.readFields(in);
    v.visit(ImageElement.DELEGATION_KEY, key.toString());
  }
  v.leaveEnclosingElement();
  v.visit(ImageElement.DELEGATION_TOKEN_SEQUENCE_NUMBER, in.readInt());
  int numDTokens = in.readInt();
  v.visitEnclosingElement(ImageElement.DELEGATION_TOKENS,
      ImageElement.NUM_DELEGATION_TOKENS, numDTokens);
  for(int i=0; i<numDTokens; i++){
    DelegationTokenIdentifier id = new  DelegationTokenIdentifier();
    id.readFields(in);
    v.visit(ImageElement.DELEGATION_TOKEN_IDENTIFIER, id.toString());
  }
  v.leaveEnclosingElement();
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Process the blocks section of the fsimage.
 *
 * @param in Datastream to process
 * @param v Visitor to walk over inodes
 * @param skipBlocks Walk over each block?
 */
private void processBlocks(DataInputStream in, ImageVisitor v,
    int numBlocks, boolean skipBlocks) throws IOException {
  v.visitEnclosingElement(ImageElement.BLOCKS,
                          ImageElement.NUM_BLOCKS, numBlocks);
  
  // directory or symlink or reference node, no blocks to process    
  if(numBlocks < 0) { 
    v.leaveEnclosingElement(); // Blocks
    return;
  }
  
  if(skipBlocks) {
    int bytesToSkip = ((Long.SIZE * 3 /* fields */) / 8 /*bits*/) * numBlocks;
    if(in.skipBytes(bytesToSkip) != bytesToSkip)
      throw new IOException("Error skipping over blocks");
    
  } else {
    for(int j = 0; j < numBlocks; j++) {
      v.visitEnclosingElement(ImageElement.BLOCK);
      v.visit(ImageElement.BLOCK_ID, in.readLong());
      v.visit(ImageElement.NUM_BYTES, in.readLong());
      v.visit(ImageElement.GENERATION_STAMP, in.readLong());
      v.leaveEnclosingElement(); // Block
    }
  }
  v.leaveEnclosingElement(); // Blocks
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Extract the INode permissions stored in the fsimage file.
 *
 * @param in Datastream to process
 * @param v Visitor to walk over inodes
 */
private void processPermission(DataInputStream in, ImageVisitor v)
    throws IOException {
  v.visitEnclosingElement(ImageElement.PERMISSIONS);
  v.visit(ImageElement.USER_NAME, Text.readString(in));
  v.visit(ImageElement.GROUP_NAME, Text.readString(in));
  FsPermission fsp = new FsPermission(in.readShort());
  v.visit(ImageElement.PERMISSION_STRING, fsp.toString());
  v.leaveEnclosingElement(); // Permissions
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
/**
 * Extract CachePool permissions stored in the fsimage file.
 *
 * @param in Datastream to process
 * @param v Visitor to walk over inodes
 */
private void processCachePoolPermission(DataInputStream in, ImageVisitor v)
    throws IOException {
  v.visitEnclosingElement(ImageElement.PERMISSIONS);
  v.visit(ImageElement.CACHE_POOL_OWNER_NAME, Text.readString(in));
  v.visit(ImageElement.CACHE_POOL_GROUP_NAME, Text.readString(in));
  FsPermission fsp = new FsPermission(in.readShort());
  v.visit(ImageElement.CACHE_POOL_PERMISSION_STRING, fsp.toString());
  v.leaveEnclosingElement(); // Permissions
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
private void processSnapshot(DataInputStream in, ImageVisitor v)
    throws IOException {
  v.visitEnclosingElement(ImageElement.SNAPSHOT);
  v.visit(ImageElement.SNAPSHOT_ID, in.readInt());
  // process root of snapshot
  v.visitEnclosingElement(ImageElement.SNAPSHOT_ROOT);
  processINode(in, v, true, "", false);
  v.leaveEnclosingElement();
  v.leaveEnclosingElement();
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
private void processDirectoryDiffList(DataInputStream in, ImageVisitor v,
    String currentINodeName) throws IOException {
  final int numDirDiff = in.readInt();
  if (numDirDiff >= 0) {
    v.visitEnclosingElement(ImageElement.SNAPSHOT_DIR_DIFFS,
        ImageElement.NUM_SNAPSHOT_DIR_DIFF, numDirDiff);
    for (int i = 0; i < numDirDiff; i++) {
      // process directory diffs in reverse chronological oder
      processDirectoryDiff(in, v, currentINodeName); 
    }
    v.leaveEnclosingElement();
  }
}
 

import org.apache.hadoop.hdfs.tools.offlineImageViewer.ImageVisitor.ImageElement; //导入依赖的package包/类
private void processINodeDirectoryAttributes(DataInputStream in, ImageVisitor v,
    String parentName) throws IOException {
  final String pathName = readINodePath(in, parentName);
  v.visit(ImageElement.INODE_PATH, pathName);
  processPermission(in, v);
  v.visit(ImageElement.MODIFICATION_TIME, formatDate(in.readLong()));

  v.visit(ImageElement.NS_QUOTA, in.readLong());
  v.visit(ImageElement.DS_QUOTA, in.readLong());
}