* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* DataNode is a class (and program) that stores a set of

* blocks for a DFS deployment.  A single deployment can

* have one or many DataNodes.  Each DataNode communicates

* regularly with a single NameNode.  It also communicates

* with client code and other DataNodes from time to time.

*

* DataNodes store a series of named blocks.  The DataNode

* allows client code to read these blocks, or to write new

* block data.  The DataNode may also, in response to instructions

* from its NameNode, delete blocks or copy blocks to/from other

* DataNodes.

*

* The DataNode maintains just one critical table:

*   block-> stream of bytes (of BLOCK_SIZE or less)

*

* This info is stored on a local disk.  The DataNode

* reports the table's contents to the NameNode upon startup

* and every so often afterwards.

*

* DataNodes spend their lives in an endless loop of asking

* the NameNode for something to do.  A NameNode cannot connect

* to a DataNode directly; a NameNode simply returns values from

* functions invoked by a DataNode.

*

* DataNodes maintain an open server socket so that client code

* or other DataNodes can read/write data.  The host/port for

* this server is reported to the NameNode, which then sends that

* information to clients or other DataNodes that might be interested.

*

**********************************************************/

    implements InterDatanodeProtocol, ClientDatanodeProtocol, FSConstants, PulseCheckable,

    DataNodeMXBean {

  public static final Log LOG = LogFactory.getLog(DataNode.class);

 

  static{

    Configuration.addDefaultResource("hdfs-default.xml");

    Configuration.addDefaultResource("hdfs-site.xml");

  }

  public static final String DN_CLIENTTRACE_FORMAT =

        "src: %s" +      // src IP

        ", dest: %s" +   // dst IP

        ", bytes: %s" +  // byte count

        ", op: %s" +     // operation

        ", cliID: %s" +  // DFSClient id

        ", offset: %s" + // offset

        ", srvID: %s" +  // DatanodeRegistration

        ", blockid: %s" + // block id

        ", duration: %s"; // duration time

  public static final Log ClientTraceLog =

    LogFactory.getLog(DataNode.class.getName() + ".clienttrace");

  /**

   * Use {@link NetUtils#createSocketAddr(String)} instead.

   */

  @Deprecated

  public static InetSocketAddress createSocketAddr(String target

                                                   ) throws IOException {

    return NetUtils.createSocketAddr(target);

  }

 

  public FSDatasetInterface data = null;

 

  //TODO this should be not used at all

  private static InetSocketAddress nameNodeAddr;

  public static int NAMESPACE_ID = 12345678;

  volatile boolean shouldRun = true;

  boolean isAlive = false;

 

  protected NamespaceManager namespaceManager;

 

  /** list of blocks being recovered */

  private final Map<Block, Block> ongoingRecovery = new HashMap<Block, Block>();

  AtomicInteger xmitsInProgress = new AtomicInteger();

  AtomicBoolean shuttingDown = new AtomicBoolean(false);

  AtomicBoolean checkingDisk = new AtomicBoolean(false);

  volatile long timeLastCheckDisk = 0;

  long minDiskCheckIntervalMsec;

  Daemon dataXceiverServer = null;

  ThreadGroup threadGroup = null;

  long blockReportInterval;

  long deletedReportInterval;

  long initialBlockReportDelay = BLOCKREPORT_INITIAL_DELAY * 1000L;

  long heartBeatInterval;

  DataStorage storage = null;

  HttpServer infoServer = null;

  DataNodeMetrics myMetrics;

 

  protected InetSocketAddress selfAddr;

  String machineName;

  static String dnThreadName;

  int socketTimeout;

  int socketReadExtentionTimeout;

  int socketWriteTimeout = 0;

  int socketWriteExtentionTimeout = 0; 

  boolean transferToAllowed = true;

  boolean ignoreChecksumWhenRead = false;

  int writePacketSize = 0;

  boolean syncOnClose;

  boolean supportAppends;

  long heartbeatExpireInterval;

  // heartbeatExpireInterval is how long namenode waits for datanode to report

 

  /**

   * Testing hook that allows tests to delay the sending of blockReceived

   * RPCs to the namenode. This can help find bugs in append.

   */

  int artificialBlockReceivedDelay = 0;

  public DataBlockScannerSet blockScanner = null;

 

  private static final String CONF_SERVLET_PATH = "/dnconf";

 

  private static final Random R = new Random();

 

  // For InterDataNodeProtocol

  public Server ipcServer;

  private final ExecutorService blockCopyExecutor;

  public static final int BLOCK_COPY_THREAD_POOL_SIZE = 10;

  private final int blockCopyRPCWaitTime;

  AbstractList<File> dataDirs;

  Configuration conf;

  private PulseChecker pulseChecker;

  /**

   * Current system time.

   * @return current time in msec.

   */

  static long now() {

    return System.currentTimeMillis();

  }

  /**

   * Create the DataNode given a configuration and an array of dataDirs.

   * 'dataDirs' is where the blocks are stored.

   */

  DataNode(Configuration conf,

          AbstractList<File> dataDirs) throws IOException {

   super(conf);

   supportAppends = conf.getBoolean("dfs.support.append", false);

   // TODO(pritam): Integrate this into a threadpool for all operations of the

   // datanode.

   blockCopyExecutor = Executors.newCachedThreadPool();

   // Time that the blocking version of  RPC for copying block between

   // datanodes should wait for. Default is 5 minutes.

   blockCopyRPCWaitTime = conf.getInt("dfs.datanode.blkcopy.wait_time",

       5 * 60);

   try {

     startDataNode(this.getConf(), dataDirs);

   } catch (IOException ie) {

     LOG.info("Failed to start datanode " + StringUtils.stringifyException(ie));

     shutdown();

     throw ie;

   }

}

  /**

   * Initialize global settings for DN

   */

  protected void initGlobalSetting(Configuration conf,

      AbstractList<File> dataDirs) throws IOException {

    this.dataDirs = dataDirs;

    this.conf = conf;

    storage = new DataStorage(this);

   

    // global DN settings

    initConfig(conf);

    registerMXBean();

    initDataXceiver(conf);

    startInfoServer(conf);

    initIpcServer(conf);

    myMetrics = new DataNodeMetrics(conf, storage.getStorageID());

  }

 

  /**

   * Initialize dataset and block scanner

   *

   * @param conf  Configuration

   * @param dataDirs data directories

   * @param numOfNameSpaces number of name spaces

   * @throws IOException

   */

  protected void initDataSetAndScanner(Configuration conf,

      AbstractList<File> dataDirs, int numOfNameSpaces) throws IOException {

    initFsDataSet(conf, dataDirs, numOfNameSpaces);

    initDataBlockScanner(conf);

  }

 

  /**

   * This method starts the data node with the specified conf.

   *

   * @param conf - the configuration

   *  if conf's CONFIG_PROPERTY_SIMULATED property is set

   *  then a simulated storage based data node is created.

   *

   * @param dataDirs - only for a non-simulated storage data node

   * @throws IOException

   */

  void startDataNode(Configuration conf,

                     AbstractList<File> dataDirs

                     ) throws IOException {

    initGlobalSetting(conf, dataDirs);

   

    /* Initialize namespace manager */

    List<InetSocketAddress> nameNodeAddrs = DFSUtil.getNNServiceRpcAddresses(conf);

   

    //TODO this will be no longer valid, since we will have multiple namenodes

    // We might want to keep it and assign the first NN to it.

    DataNode.nameNodeAddr = nameNodeAddrs.get(0);

    namespaceManager = new NamespaceManager(conf, nameNodeAddrs);

 

    initDataSetAndScanner(conf, dataDirs, nameNodeAddrs.size());

  }

 

  private void initConfig(Configuration conf) throws IOException {

    if (conf.get("slave.host.name") != null) {

      machineName = conf.get("slave.host.name");  

    }

    if (machineName == null) {

      machineName = DNS.getDefaultHost(

                                     conf.get("dfs.datanode.dns.interface","default"),

                                     conf.get("dfs.datanode.dns.nameserver","default"));

    }

    // Allow configuration to delay block reports to find bugs

    artificialBlockReceivedDelay = conf.getInt(

      "dfs.datanode.artificialBlockReceivedDelay", 0);

    if (conf.getBoolean(

        ServiceAuthorizationManager.SERVICE_AUTHORIZATION_CONFIG, false)) {

      PolicyProvider policyProvider = (PolicyProvider) (ReflectionUtils

          .newInstance(conf.getClass(PolicyProvider.POLICY_PROVIDER_CONFIG,

              HDFSPolicyProvider.class, PolicyProvider.class), conf));

      SecurityUtil.setPolicy(new ConfiguredPolicy(conf, policyProvider));

    }

    this.socketTimeout = conf.getInt("dfs.socket.timeout",

        HdfsConstants.READ_TIMEOUT);

    this.socketReadExtentionTimeout = conf.getInt(

        HdfsConstants.DFS_DATANODE_READ_EXTENSION,

        HdfsConstants.READ_TIMEOUT_EXTENSION);

    this.socketWriteTimeout = conf.getInt("dfs.datanode.socket.write.timeout",

        HdfsConstants.WRITE_TIMEOUT);

    this.socketWriteExtentionTimeout = conf.getInt(

        HdfsConstants.DFS_DATANODE_WRITE_EXTENTSION,

        HdfsConstants.WRITE_TIMEOUT_EXTENSION);

   

    /* Based on results on different platforms, we might need set the default

     * to false on some of them. */

    this.transferToAllowed = conf.getBoolean("dfs.datanode.transferTo.allowed",

                                             true);

    // TODO: remove the global setting and change data protocol to support

    // per session setting for this value.

    this.ignoreChecksumWhenRead = conf.getBoolean("dfs.datanode.read.ignore.checksum",

        false);

    this.writePacketSize = conf.getInt("dfs.write.packet.size", 64*1024);

   

    this.deletedReportInterval =

      conf.getLong("dfs.blockreport.intervalMsec", BLOCKREPORT_INTERVAL);

    // Calculate the full block report interval

    int fullReportMagnifier = conf.getInt("dfs.fullblockreport.magnifier", 2);

    this.blockReportInterval = fullReportMagnifier * deletedReportInterval;

    this.heartBeatInterval = conf.getLong("dfs.heartbeat.interval", HEARTBEAT_INTERVAL) * 1000L;

    long heartbeatRecheckInterval = conf.getInt(

        "heartbeat.recheck.interval", 5 * 60 * 1000); // 5 minutes

    this.heartbeatExpireInterval = 2 * heartbeatRecheckInterval +

        10 * heartBeatInterval;

   

    this.initialBlockReportDelay = conf.getLong("dfs.blockreport.initialDelay",

        BLOCKREPORT_INITIAL_DELAY) * 1000L;

    if (this.initialBlockReportDelay >= blockReportInterval) {

      this.initialBlockReportDelay = 0;

      LOG.info("dfs.blockreport.initialDelay is greater than "

          + "dfs.blockreport.intervalMsec."

          + " Setting initial delay to 0 msec:");

    }

    // do we need to sync block file contents to disk when blockfile is closed?

    this.syncOnClose = conf.getBoolean("dfs.datanode.synconclose", false);

   

    this.minDiskCheckIntervalMsec = conf.getLong(

        "dfs.datnode.checkdisk.mininterval",

        FSConstants.MIN_INTERVAL_CHECK_DIR_MSEC);

  }

 

  /**

   * Used only for testing.

   *

   * @param name

   *          the new name for datanode registration.

   */

  public void setRegistrationName(String name) {

    NamespaceService[] nsos = namespaceManager.getAllNamenodeThreads();

    for (NamespaceService ns : nsos) {

      ((NSOfferService) ns).setRegistrationName(name);