INodeFile.java
上传用户:quxuerui
上传日期:2018-01-08
资源大小:41811k
文件大小:5k
源码类别:

网格计算

开发平台:

Java

  1. /**
  2.  * Licensed to the Apache Software Foundation (ASF) under one
  3.  * or more contributor license agreements.  See the NOTICE file
  4.  * distributed with this work for additional information
  5.  * regarding copyright ownership.  The ASF licenses this file
  6.  * to you under the Apache License, Version 2.0 (the
  7.  * "License"); you may not use this file except in compliance
  8.  * with the License.  You may obtain a copy of the License at
  9.  *
  10.  *     http://www.apache.org/licenses/LICENSE-2.0
  11.  *
  12.  * Unless required by applicable law or agreed to in writing, software
  13.  * distributed under the License is distributed on an "AS IS" BASIS,
  14.  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15.  * See the License for the specific language governing permissions and
  16.  * limitations under the License.
  17.  */
  18. package org.apache.hadoop.hdfs.server.namenode;
  19. import java.io.IOException;
  20. import java.util.List;
  21. import org.apache.hadoop.fs.permission.FsAction;
  22. import org.apache.hadoop.fs.permission.FsPermission;
  23. import org.apache.hadoop.fs.permission.PermissionStatus;
  24. import org.apache.hadoop.hdfs.protocol.Block;
  25. import org.apache.hadoop.hdfs.server.namenode.BlocksMap.BlockInfo;
  26. class INodeFile extends INode {
  27.   static final FsPermission UMASK = FsPermission.createImmutable((short)0111);
  28.   protected BlockInfo blocks[] = null;
  29.   protected short blockReplication;
  30.   protected long preferredBlockSize;
  31.   INodeFile(PermissionStatus permissions,
  32.             int nrBlocks, short replication, long modificationTime,
  33.             long atime, long preferredBlockSize) {
  34.     this(permissions, new BlockInfo[nrBlocks], replication,
  35.         modificationTime, atime, preferredBlockSize);
  36.   }
  37.   protected INodeFile() {
  38.     blocks = null;
  39.     blockReplication = 0;
  40.     preferredBlockSize = 0;
  41.   }
  42.   protected INodeFile(PermissionStatus permissions, BlockInfo[] blklist,
  43.                       short replication, long modificationTime,
  44.                       long atime, long preferredBlockSize) {
  45.     super(permissions, modificationTime, atime);
  46.     this.blockReplication = replication;
  47.     this.preferredBlockSize = preferredBlockSize;
  48.     blocks = blklist;
  49.   }
  50.   /**
  51.    * Set the {@link FsPermission} of this {@link INodeFile}.
  52.    * Since this is a file,
  53.    * the {@link FsAction#EXECUTE} action, if any, is ignored.
  54.    */
  55.   protected void setPermission(FsPermission permission) {
  56.     super.setPermission(permission.applyUMask(UMASK));
  57.   }
  58.   public boolean isDirectory() {
  59.     return false;
  60.   }
  61.   /**
  62.    * Get block replication for the file 
  63.    * @return block replication
  64.    */
  65.   public short getReplication() {
  66.     return this.blockReplication;
  67.   }
  68.   void setReplication(short replication) {
  69.     this.blockReplication = replication;
  70.   }
  71.   /**
  72.    * Get file blocks 
  73.    * @return file blocks
  74.    */
  75.   BlockInfo[] getBlocks() {
  76.     return this.blocks;
  77.   }
  78.   /**
  79.    * add a block to the block list
  80.    */
  81.   void addBlock(BlockInfo newblock) {
  82.     if (this.blocks == null) {
  83.       this.blocks = new BlockInfo[1];
  84.       this.blocks[0] = newblock;
  85.     } else {
  86.       int size = this.blocks.length;
  87.       BlockInfo[] newlist = new BlockInfo[size + 1];
  88.       System.arraycopy(this.blocks, 0, newlist, 0, size);
  89.       newlist[size] = newblock;
  90.       this.blocks = newlist;
  91.     }
  92.   }
  93.   /**
  94.    * Set file block
  95.    */
  96.   void setBlock(int idx, BlockInfo blk) {
  97.     this.blocks[idx] = blk;
  98.   }
  99.   int collectSubtreeBlocksAndClear(List<Block> v) {
  100.     parent = null;
  101.     for (Block blk : blocks) {
  102.       v.add(blk);
  103.     }
  104.     blocks = null;
  105.     return 1;
  106.   }
  107.   /** {@inheritDoc} */
  108.   long[] computeContentSummary(long[] summary) {
  109.     long bytes = 0;
  110.     for(Block blk : blocks) {
  111.       bytes += blk.getNumBytes();
  112.     }
  113.     summary[0] += bytes;
  114.     summary[1]++;
  115.     summary[3] += diskspaceConsumed();
  116.     return summary;
  117.   }
  118.   
  119.   @Override
  120.   DirCounts spaceConsumedInTree(DirCounts counts) {
  121.     counts.nsCount += 1;
  122.     counts.dsCount += diskspaceConsumed();
  123.     return counts;
  124.   }
  125.   long diskspaceConsumed() {
  126.     return diskspaceConsumed(blocks);
  127.   }
  128.   
  129.   long diskspaceConsumed(Block[] blkArr) {
  130.     long size = 0;
  131.     for (Block blk : blkArr) {
  132.       if (blk != null) {
  133.         size += blk.getNumBytes();
  134.       }
  135.     }
  136.     /* If the last block is being written to, use prefferedBlockSize
  137.      * rather than the actual block size.
  138.      */
  139.     if (blkArr.length > 0 && blkArr[blkArr.length-1] != null && 
  140.         isUnderConstruction()) {
  141.       size += preferredBlockSize - blocks[blocks.length-1].getNumBytes();
  142.     }
  143.     return size * blockReplication;
  144.   }
  145.   
  146.   /**
  147.    * Get the preferred block size of the file.
  148.    * @return the number of bytes
  149.    */
  150.   public long getPreferredBlockSize() {
  151.     return preferredBlockSize;
  152.   }
  153.   /**
  154.    * Return the penultimate allocated block for this file.
  155.    */
  156.   Block getPenultimateBlock() {
  157.     if (blocks == null || blocks.length <= 1) {
  158.       return null;
  159.     }
  160.     return blocks[blocks.length - 2];
  161.   }
  162.   INodeFileUnderConstruction toINodeFileUnderConstruction(
  163.       String clientName, String clientMachine, DatanodeDescriptor clientNode
  164.       ) throws IOException {
  165.     if (isUnderConstruction()) {
  166.       return (INodeFileUnderConstruction)this;
  167.     }
  168.     return new INodeFileUnderConstruction(name,
  169.         blockReplication, modificationTime, preferredBlockSize,
  170.         blocks, getPermissionStatus(),
  171.         clientName, clientMachine, clientNode);
  172.   }
  173. }