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

网格计算

开发平台:

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.protocol;
  19. import org.apache.hadoop.io.*;
  20. import java.io.*;
  21. /****************************************************
  22.  * A LocatedBlock is a pair of Block, DatanodeInfo[]
  23.  * objects.  It tells where to find a Block.
  24.  * 
  25.  ****************************************************/
  26. public class LocatedBlock implements Writable {
  27.   static {                                      // register a ctor
  28.     WritableFactories.setFactory
  29.       (LocatedBlock.class,
  30.        new WritableFactory() {
  31.          public Writable newInstance() { return new LocatedBlock(); }
  32.        });
  33.   }
  34.   private Block b;
  35.   private long offset;  // offset of the first byte of the block in the file
  36.   private DatanodeInfo[] locs;
  37.   // corrupt flag is true if all of the replicas of a block are corrupt.
  38.   // else false. If block has few corrupt replicas, they are filtered and 
  39.   // their locations are not part of this object
  40.   private boolean corrupt;
  41.   /**
  42.    */
  43.   public LocatedBlock() {
  44.     this(new Block(), new DatanodeInfo[0], 0L, false);
  45.   }
  46.   /**
  47.    */
  48.   public LocatedBlock(Block b, DatanodeInfo[] locs) {
  49.     this(b, locs, -1, false); // startOffset is unknown
  50.   }
  51.   /**
  52.    */
  53.   public LocatedBlock(Block b, DatanodeInfo[] locs, long startOffset) {
  54.     this(b, locs, startOffset, false);
  55.   }
  56.   /**
  57.    */
  58.   public LocatedBlock(Block b, DatanodeInfo[] locs, long startOffset, 
  59.                       boolean corrupt) {
  60.     this.b = b;
  61.     this.offset = startOffset;
  62.     this.corrupt = corrupt;
  63.     if (locs==null) {
  64.       this.locs = new DatanodeInfo[0];
  65.     } else {
  66.       this.locs = locs;
  67.     }
  68.   }
  69.   /**
  70.    */
  71.   public Block getBlock() {
  72.     return b;
  73.   }
  74.   /**
  75.    */
  76.   public DatanodeInfo[] getLocations() {
  77.     return locs;
  78.   }
  79.   
  80.   public long getStartOffset() {
  81.     return offset;
  82.   }
  83.   
  84.   public long getBlockSize() {
  85.     return b.getNumBytes();
  86.   }
  87.   void setStartOffset(long value) {
  88.     this.offset = value;
  89.   }
  90.   void setCorrupt(boolean corrupt) {
  91.     this.corrupt = corrupt;
  92.   }
  93.   
  94.   public boolean isCorrupt() {
  95.     return this.corrupt;
  96.   }
  97.   ///////////////////////////////////////////
  98.   // Writable
  99.   ///////////////////////////////////////////
  100.   public void write(DataOutput out) throws IOException {
  101.     out.writeBoolean(corrupt);
  102.     out.writeLong(offset);
  103.     b.write(out);
  104.     out.writeInt(locs.length);
  105.     for (int i = 0; i < locs.length; i++) {
  106.       locs[i].write(out);
  107.     }
  108.   }
  109.   public void readFields(DataInput in) throws IOException {
  110.     this.corrupt = in.readBoolean();
  111.     offset = in.readLong();
  112.     this.b = new Block();
  113.     b.readFields(in);
  114.     int count = in.readInt();
  115.     this.locs = new DatanodeInfo[count];
  116.     for (int i = 0; i < locs.length; i++) {
  117.       locs[i] = new DatanodeInfo();
  118.       locs[i].readFields(in);
  119.     }
  120.   }
  121. }