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

网格计算

开发平台:

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 org.apache.hadoop.fs.permission.PermissionStatus;
  21. import org.apache.hadoop.hdfs.protocol.Block;
  22. import org.apache.hadoop.hdfs.server.namenode.BlocksMap.BlockInfo;
  23. class INodeFileUnderConstruction extends INodeFile {
  24.   final String clientName;         // lease holder
  25.   private final String clientMachine;
  26.   private final DatanodeDescriptor clientNode; // if client is a cluster node too.
  27.   private int primaryNodeIndex = -1; //the node working on lease recovery
  28.   private DatanodeDescriptor[] targets = null;   //locations for last block
  29.   private long lastRecoveryTime = 0;
  30.   
  31.   INodeFileUnderConstruction(PermissionStatus permissions,
  32.                              short replication,
  33.                              long preferredBlockSize,
  34.                              long modTime,
  35.                              String clientName,
  36.                              String clientMachine,
  37.                              DatanodeDescriptor clientNode) {
  38.     super(permissions.applyUMask(UMASK), 0, replication, modTime, modTime,
  39.         preferredBlockSize);
  40.     this.clientName = clientName;
  41.     this.clientMachine = clientMachine;
  42.     this.clientNode = clientNode;
  43.   }
  44.   public INodeFileUnderConstruction(byte[] name,
  45.                              short blockReplication,
  46.                              long modificationTime,
  47.                              long preferredBlockSize,
  48.                              BlockInfo[] blocks,
  49.                              PermissionStatus perm,
  50.                              String clientName,
  51.                              String clientMachine,
  52.                              DatanodeDescriptor clientNode) {
  53.     super(perm, blocks, blockReplication, modificationTime, modificationTime,
  54.           preferredBlockSize);
  55.     setLocalName(name);
  56.     this.clientName = clientName;
  57.     this.clientMachine = clientMachine;
  58.     this.clientNode = clientNode;
  59.   }
  60.   String getClientName() {
  61.     return clientName;
  62.   }
  63.   String getClientMachine() {
  64.     return clientMachine;
  65.   }
  66.   DatanodeDescriptor getClientNode() {
  67.     return clientNode;
  68.   }
  69.   /**
  70.    * Is this inode being constructed?
  71.    */
  72.   @Override
  73.   boolean isUnderConstruction() {
  74.     return true;
  75.   }
  76.   DatanodeDescriptor[] getTargets() {
  77.     return targets;
  78.   }
  79.   void setTargets(DatanodeDescriptor[] targets) {
  80.     this.targets = targets;
  81.     this.primaryNodeIndex = -1;
  82.   }
  83.   //
  84.   // converts a INodeFileUnderConstruction into a INodeFile
  85.   // use the modification time as the access time
  86.   //
  87.   INodeFile convertToInodeFile() {
  88.     INodeFile obj = new INodeFile(getPermissionStatus(),
  89.                                   getBlocks(),
  90.                                   getReplication(),
  91.                                   getModificationTime(),
  92.                                   getModificationTime(),
  93.                                   getPreferredBlockSize());
  94.     return obj;
  95.     
  96.   }
  97.   /**
  98.    * remove a block from the block list. This block should be
  99.    * the last one on the list.
  100.    */
  101.   void removeBlock(Block oldblock) throws IOException {
  102.     if (blocks == null) {
  103.       throw new IOException("Trying to delete non-existant block " + oldblock);
  104.     }
  105.     int size_1 = blocks.length - 1;
  106.     if (!blocks[size_1].equals(oldblock)) {
  107.       throw new IOException("Trying to delete non-last block " + oldblock);
  108.     }
  109.     //copy to a new list
  110.     BlockInfo[] newlist = new BlockInfo[size_1];
  111.     System.arraycopy(blocks, 0, newlist, 0, size_1);
  112.     blocks = newlist;
  113.     
  114.     // Remove the block locations for the last block.
  115.     targets = null;
  116.   }
  117.   synchronized void setLastBlock(BlockInfo newblock, DatanodeDescriptor[] newtargets
  118.       ) throws IOException {
  119.     if (blocks == null) {
  120.       throw new IOException("Trying to update non-existant block (newblock="
  121.           + newblock + ")");
  122.     }
  123.     blocks[blocks.length - 1] = newblock;
  124.     setTargets(newtargets);
  125.     lastRecoveryTime = 0;
  126.   }
  127.   /**
  128.    * Initialize lease recovery for this object
  129.    */
  130.   void assignPrimaryDatanode() {
  131.     //assign the first alive datanode as the primary datanode
  132.     if (targets.length == 0) {
  133.       NameNode.stateChangeLog.warn("BLOCK*"
  134.         + " INodeFileUnderConstruction.initLeaseRecovery:"
  135.         + " No blocks found, lease removed.");
  136.     }
  137.     int previous = primaryNodeIndex;
  138.     //find an alive datanode beginning from previous
  139.     for(int i = 1; i <= targets.length; i++) {
  140.       int j = (previous + i)%targets.length;
  141.       if (targets[j].isAlive) {
  142.         DatanodeDescriptor primary = targets[primaryNodeIndex = j]; 
  143.         primary.addBlockToBeRecovered(blocks[blocks.length - 1], targets);
  144.         NameNode.stateChangeLog.info("BLOCK* " + blocks[blocks.length - 1]
  145.           + " recovery started, primary=" + primary);
  146.         return;
  147.       }
  148.     }
  149.   }
  150.   
  151.   /**
  152.    * Update lastRecoveryTime if expired.
  153.    * @return true if lastRecoveryTimeis updated. 
  154.    */
  155.   synchronized boolean setLastRecoveryTime(long now) {
  156.     boolean expired = now - lastRecoveryTime > NameNode.LEASE_RECOVER_PERIOD;
  157.     if (expired) {
  158.       lastRecoveryTime = now;
  159.     }
  160.     return expired;
  161.   }
  162. }