* 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,

    DataNodeMXBean {

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

 

  static{

    HdfsConfiguration.init();

  }

  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

       

  static final Log ClientTraceLog =

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

 

  private static final String USAGE =

      "Usage: java DataNode [-regular | -rollback | -rollingupgrade rollback]\n" +

      "    -regular                 : Normal DataNode startup (default).\n" +

      "    -rollback                : Rollback a standard upgrade.\n" +

      "    -rollingupgrade rollback : Rollback a rolling upgrade operation.\n" +

      "  Refer to HDFS documentation for the difference between standard\n" +

      "  and rolling upgrades.";

  static final int CURRENT_BLOCK_FORMAT_VERSION = 1;

  /**

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

   */

  @Deprecated

  public static InetSocketAddress createSocketAddr(String target) {

    return NetUtils.createSocketAddr(target);

  }

 

  volatile boolean shouldRun = true;

  volatile boolean shutdownForUpgrade = false;

  private boolean shutdownInProgress = false;

  private BlockPoolManager blockPoolManager;

  volatile FsDatasetSpi<? extends FsVolumeSpi> data = null;

  private String clusterId = null;

  public final static String EMPTY_DEL_HINT = "";

  final AtomicInteger xmitsInProgress = new AtomicInteger();

  Daemon dataXceiverServer = null;

  Daemon localDataXceiverServer = null;

  ShortCircuitRegistry shortCircuitRegistry = null;

  ThreadGroup threadGroup = null;

  private DNConf dnConf;

  private volatile boolean heartbeatsDisabledForTests = false;

  private DataStorage storage = null;

  private HttpServer2 infoServer = null;

  private int infoPort;

  private int infoSecurePort;

  DataNodeMetrics metrics;

  private InetSocketAddress streamingAddr;

 

  private String hostName;

  private DatanodeID id;

 

  final private String fileDescriptorPassingDisabledReason;

  boolean isBlockTokenEnabled;

  BlockPoolTokenSecretManager blockPoolTokenSecretManager;

  private boolean hasAnyBlockPoolRegistered = false;

 

  volatile DataBlockScanner blockScanner = null;

  private DirectoryScanner directoryScanner = null;

 

  /** Activated plug-ins. */

  private List<ServicePlugin> plugins;

 

  // For InterDataNodeProtocol

  public RPC.Server ipcServer;

  private JvmPauseMonitor pauseMonitor;

  private SecureResources secureResources = null;

  private List<StorageLocation> dataDirs;

  private Configuration conf;

  private final String confVersion;

  private final long maxNumberOfBlocksToLog;

  private final List<String> usersWithLocalPathAccess;

  private final boolean connectToDnViaHostname;

  ReadaheadPool readaheadPool;

  private final boolean getHdfsBlockLocationsEnabled;

  private ObjectName dataNodeInfoBeanName;

  private Thread checkDiskErrorThread = null;

  protected final int checkDiskErrorInterval = 5*1000;

  private boolean checkDiskErrorFlag = false;

  private Object checkDiskErrorMutex = new Object();

  private long lastDiskErrorCheck;

  private String supergroup;

  private boolean isPermissionEnabled;

  private String dnUserName = null;

  /**

   * Create the DataNode given a configuration, an array of dataDirs,

   * and a namenode proxy

   */

  DataNode(final Configuration conf,

           final List<StorageLocation> dataDirs,

           final SecureResources resources) throws IOException {

    super(conf);

    this.lastDiskErrorCheck = 0;

    this.maxNumberOfBlocksToLog = conf.getLong(DFS_MAX_NUM_BLOCKS_TO_LOG_KEY,

        DFS_MAX_NUM_BLOCKS_TO_LOG_DEFAULT);

    this.usersWithLocalPathAccess = Arrays.asList(

        conf.getTrimmedStrings(DFSConfigKeys.DFS_BLOCK_LOCAL_PATH_ACCESS_USER_KEY));

    this.connectToDnViaHostname = conf.getBoolean(

        DFSConfigKeys.DFS_DATANODE_USE_DN_HOSTNAME,

        DFSConfigKeys.DFS_DATANODE_USE_DN_HOSTNAME_DEFAULT);

    this.getHdfsBlockLocationsEnabled = conf.getBoolean(

        DFSConfigKeys.DFS_HDFS_BLOCKS_METADATA_ENABLED,

        DFSConfigKeys.DFS_HDFS_BLOCKS_METADATA_ENABLED_DEFAULT);

    this.supergroup = conf.get(DFSConfigKeys.DFS_PERMISSIONS_SUPERUSERGROUP_KEY,

        DFSConfigKeys.DFS_PERMISSIONS_SUPERUSERGROUP_DEFAULT);

    this.isPermissionEnabled = conf.getBoolean(

        DFSConfigKeys.DFS_PERMISSIONS_ENABLED_KEY,

        DFSConfigKeys.DFS_PERMISSIONS_ENABLED_DEFAULT);

    confVersion = "core-" +

        conf.get("hadoop.common.configuration.version", "UNSPECIFIED") +

        ",hdfs-" +

        conf.get("hadoop.hdfs.configuration.version", "UNSPECIFIED");

    // Determine whether we should try to pass file descriptors to clients.

    if (conf.getBoolean(DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY,

              DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_DEFAULT)) {

      String reason = DomainSocket.getLoadingFailureReason();

      if (reason != null) {

        LOG.warn("File descriptor passing is disabled because " + reason);

        this.fileDescriptorPassingDisabledReason = reason;

      } else {

        LOG.info("File descriptor passing is enabled.");

        this.fileDescriptorPassingDisabledReason = null;

      }

    } else {

      this.fileDescriptorPassingDisabledReason =

          "File descriptor passing was not configured.";

      LOG.debug(this.fileDescriptorPassingDisabledReason);

    }

    try {

      hostName = getHostName(conf);

      LOG.info("Configured hostname is " + hostName);

      startDataNode(conf, dataDirs, resources);

    } catch (IOException ie) {

      shutdown();

      throw ie;

    }

  }

  private synchronized void setClusterId(final String nsCid, final String bpid

      ) throws IOException {

    if(clusterId != null && !clusterId.equals(nsCid)) {

      throw new IOException ("Cluster IDs not matched: dn cid=" + clusterId

          + " but ns cid="+ nsCid + "; bpid=" + bpid);

    }

    // else

    clusterId = nsCid;

  }

  /**

   * Returns the hostname for this datanode. If the hostname is not

   * explicitly configured in the given config, then it is determined

   * via the DNS class.

   *

   * @param config configuration

   * @return the hostname (NB: may not be a FQDN)

   * @throws UnknownHostException if the dfs.datanode.dns.interface

   *    option is used and the hostname can not be determined

   */

  private static String getHostName(Configuration config)

      throws UnknownHostException {

    String name = config.get(DFS_DATANODE_HOST_NAME_KEY);

    if (name == null) {

      name = DNS.getDefaultHost(

          config.get(DFS_DATANODE_DNS_INTERFACE_KEY,

                     DFS_DATANODE_DNS_INTERFACE_DEFAULT),

          config.get(DFS_DATANODE_DNS_NAMESERVER_KEY,

                     DFS_DATANODE_DNS_NAMESERVER_DEFAULT));

    }

    return name;

  }

  /**

   * @see DFSUtil#getHttpPolicy(org.apache.hadoop.conf.Configuration)

   * for information related to the different configuration options and

   * Http Policy is decided.

   */

  private void startInfoServer(Configuration conf) throws IOException {

    HttpServer2.Builder builder = new HttpServer2.Builder().setName("datanode")

        .setConf(conf).setACL(new AccessControlList(conf.get(DFS_ADMIN, " ")));

    HttpConfig.Policy policy = DFSUtil.getHttpPolicy(conf);

    if (policy.isHttpEnabled()) {

      if (secureResources == null) {

        InetSocketAddress infoSocAddr = DataNode.getInfoAddr(conf);

        int port = infoSocAddr.getPort();

        builder.addEndpoint(URI.create("http://"

            + NetUtils.getHostPortString(infoSocAddr)));

        if (port == 0) {

          builder.setFindPort(true);

        }

      } else {

        // The http socket is created externally using JSVC, we add it in

        // directly.

        builder.setConnector(secureResources.getListener());

      }

    }

    if (policy.isHttpsEnabled()) {

      InetSocketAddress secInfoSocAddr = NetUtils.createSocketAddr(conf.get(

          DFS_DATANODE_HTTPS_ADDRESS_KEY, DFS_DATANODE_HTTPS_ADDRESS_DEFAULT));

      Configuration sslConf = DFSUtil.loadSslConfiguration(conf);

      DFSUtil.loadSslConfToHttpServerBuilder(builder, sslConf);

      int port = secInfoSocAddr.getPort();

      if (port == 0) {

        builder.setFindPort(true);

      }

      builder.addEndpoint(URI.create("https://"

          + NetUtils.getHostPortString(secInfoSocAddr)));

    }

    this.infoServer = builder.build();

    this.infoServer.addInternalServlet(null, "/streamFile/*", StreamFile.class);

    this.infoServer.addInternalServlet(null, "/getFileChecksum/*",

        FileChecksumServlets.GetServlet.class);

   

    this.infoServer.setAttribute("datanode", this);

    this.infoServer.setAttribute(JspHelper.CURRENT_CONF, conf);

    this.infoServer.addServlet(null, "/blockScannerReport",

                               DataBlockScanner.Servlet.class);

    if (WebHdfsFileSystem.isEnabled(conf, LOG)) {

      infoServer.addJerseyResourcePackage(DatanodeWebHdfsMethods.class

          .getPackage().getName() + ";" + Param.class.getPackage().getName(),

          WebHdfsFileSystem.PATH_PREFIX + "/*");

    }

    this.infoServer.start();

    int connIdx = 0;

    if (policy.isHttpEnabled()) {

      infoPort = infoServer.getConnectorAddress(connIdx++).getPort();

    }

    if (policy.isHttpsEnabled()) {

      infoSecurePort = infoServer.getConnectorAddress(connIdx).getPort();

    }

  }

  private void startPlugins(Configuration conf) {

    plugins = conf.getInstances(DFS_DATANODE_PLUGINS_KEY, ServicePlugin.class);

    for (ServicePlugin p: plugins) {

      try {

        p.start(this);

        LOG.info("Started plug-in " + p);

      } catch (Throwable t) {

        LOG.warn("ServicePlugin " + p + " could not be started", t);

      }

    }

  }

 

  private void initIpcServer(Configuration conf) throws IOException {

    InetSocketAddress ipcAddr = NetUtils.createSocketAddr(

        conf.get(DFS_DATANODE_IPC_ADDRESS_KEY));

   

    // Add all the RPC protocols that the Datanode implements   

    RPC.setProtocolEngine(conf, ClientDatanodeProtocolPB.class,

        ProtobufRpcEngine.class);

    ClientDatanodeProtocolServerSideTranslatorPB clientDatanodeProtocolXlator =

          new ClientDatanodeProtocolServerSideTranslatorPB(this);

    BlockingService service = ClientDatanodeProtocolService

        .newReflectiveBlockingService(clientDatanodeProtocolXlator);

    ipcServer = new RPC.Builder(conf)

        .setProtocol(ClientDatanodeProtocolPB.class)

        .setInstance(service)

        .setBindAddress(ipcAddr.getHostName())

        .setPort(ipcAddr.getPort())

        .setNumHandlers(

            conf.getInt(DFS_DATANODE_HANDLER_COUNT_KEY,

                DFS_DATANODE_HANDLER_COUNT_DEFAULT)).setVerbose(false)

        .setSecretManager(blockPoolTokenSecretManager).build();

   

    InterDatanodeProtocolServerSideTranslatorPB interDatanodeProtocolXlator =

        new InterDatanodeProtocolServerSideTranslatorPB(this);

    service = InterDatanodeProtocolService

        .newReflectiveBlockingService(interDatanodeProtocolXlator);

    DFSUtil.addPBProtocol(conf, InterDatanodeProtocolPB.class, service,

        ipcServer);

    LOG.info("Opened IPC server at " + ipcServer.getListenerAddress());

    // set service-level authorization security policy

    if (conf.getBoolean(

        CommonConfigurationKeys.HADOOP_SECURITY_AUTHORIZATION, false)) {

      ipcServer.refreshServiceAcl(conf, new HDFSPolicyProvider());

    }

  }

  /** Check whether the current user is in the superuser group. */

  private void checkSuperuserPrivilege() throws IOException, AccessControlException {

    if (!isPermissionEnabled) {

      return;

    }

    // Try to get the ugi in the RPC call.

    UserGroupInformation callerUgi = ipcServer.getRemoteUser();

    if (callerUgi == null) {

      // This is not from RPC.

      callerUgi = UserGroupInformation.getCurrentUser();

    }

    // Is this by the DN user itself?

    assert dnUserName != null;

    if (callerUgi.getShortUserName().equals(dnUserName)) {

      return;

    }

    // Is the user a member of the super group?

    List<String> groups = Arrays.asList(callerUgi.getGroupNames());

    if (groups.contains(supergroup)) {

      return;

    }

    // Not a superuser.

    throw new AccessControlException();

  }

 

* Initialize the datanode's periodic scanners:

*     {@link DataBlockScanner}

*     {@link DirectoryScanner}

* They report results on a per-blockpool basis but do their scanning

* on a per-Volume basis to minimize competition for disk iops.

*

* @param conf - Configuration has the run intervals and other

*               parameters for these periodic scanners

*/

  private void initPeriodicScanners(Configuration conf) {

    initDataBlockScanner(conf);

    initDirectoryScanner(conf);

  }

 

  private void shutdownPeriodicScanners() {

    shutdownDirectoryScanner();

    shutdownDataBlockScanner();

  }

 

  /**

   * See {@link DataBlockScanner}

   */

  private synchronized void initDataBlockScanner(Configuration conf) {

    if (blockScanner != null) {

      return;

    }

    String reason = null;

    assert data != null;

    if (conf.getInt(DFS_DATANODE_SCAN_PERIOD_HOURS_KEY,

                    DFS_DATANODE_SCAN_PERIOD_HOURS_DEFAULT) < 0) {

      reason = "verification is turned off by configuration";

    } else if ("SimulatedFSDataset".equals(data.getClass().getSimpleName())) {

      reason = "verifcation is not supported by SimulatedFSDataset";

    }

    if (reason == null) {

      blockScanner = new DataBlockScanner(this, data, conf);

      blockScanner.start();

    } else {

      LOG.info("Periodic Block Verification scan disabled because " + reason);

    }

  }

 

  private void shutdownDataBlockScanner() {

    if (blockScanner != null) {

      blockScanner.shutdown();

    }

  }

 

  /**

   * See {@link DirectoryScanner}

   */

  private synchronized void initDirectoryScanner(Configuration conf) {

    if (directoryScanner != null) {

      return;

    }

    String reason = null;

    if (conf.getInt(DFS_DATANODE_DIRECTORYSCAN_INTERVAL_KEY,

                    DFS_DATANODE_DIRECTORYSCAN_INTERVAL_DEFAULT) < 0) {

      reason = "verification is turned off by configuration";

    } else if ("SimulatedFSDataset".equals(data.getClass().getSimpleName())) {

      reason = "verifcation is not supported by SimulatedFSDataset";

    }

    if (reason == null) {

      directoryScanner = new DirectoryScanner(data, conf);

      directoryScanner.start();

    } else {

      LOG.info("Periodic Directory Tree Verification scan is disabled because " +

                   reason);

    }

  }

 

  private synchronized void shutdownDirectoryScanner() {

    if (directoryScanner != null) {

      directoryScanner.shutdown();

    }

  }

 

  private void initDataXceiver(Configuration conf) throws IOException {

    // find free port or use privileged port provided

    TcpPeerServer tcpPeerServer;

    if (secureResources != null) {

      tcpPeerServer = new TcpPeerServer(secureResources);

    } else {

      tcpPeerServer = new TcpPeerServer(dnConf.socketWriteTimeout,

          DataNode.getStreamingAddr(conf));

    }

    tcpPeerServer.setReceiveBufferSize(HdfsConstants.DEFAULT_DATA_SOCKET_SIZE);

    streamingAddr = tcpPeerServer.getStreamingAddr();

    LOG.info("Opened streaming server at " + streamingAddr);

    this.threadGroup = new ThreadGroup("dataXceiverServer");

    this.dataXceiverServer = new Daemon(threadGroup,

        new DataXceiverServer(tcpPeerServer, conf, this));

    this.threadGroup.setDaemon(true); // auto destroy when empty

    if (conf.getBoolean(DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY,

              DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_DEFAULT) ||

        conf.getBoolean(DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC,

              DFSConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC_DEFAULT)) {

      DomainPeerServer domainPeerServer =

                getDomainPeerServer(conf, streamingAddr.getPort());

      if (domainPeerServer != null) {

        this.localDataXceiverServer = new Daemon(threadGroup,

            new DataXceiverServer(domainPeerServer, conf, this));

        LOG.info("Listening on UNIX domain socket: " +

            domainPeerServer.getBindPath());

      }

    }

    this.shortCircuitRegistry = new ShortCircuitRegistry(conf);

  }

  static DomainPeerServer getDomainPeerServer(Configuration conf,

      int port) throws IOException {

    String domainSocketPath =

        conf.getTrimmed(DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY,

            DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_DEFAULT);

    if (domainSocketPath.isEmpty()) {

      if (conf.getBoolean(DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_KEY,

            DFSConfigKeys.DFS_CLIENT_READ_SHORTCIRCUIT_DEFAULT) &&

         (!conf.getBoolean(DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADERLOCAL,

          DFSConfigKeys.DFS_CLIENT_USE_LEGACY_BLOCKREADERLOCAL_DEFAULT))) {

        LOG.warn("Although short-circuit local reads are configured, " +

            "they are disabled because you didn't configure " +

            DFSConfigKeys.DFS_DOMAIN_SOCKET_PATH_KEY);

      }

      return null;

    }

    if (DomainSocket.getLoadingFailureReason() != null) {

      throw new RuntimeException("Although a UNIX domain socket " +

          "path is configured as " + domainSocketPath + ", we cannot " +

          "start a localDataXceiverServer because " +

          DomainSocket.getLoadingFailureReason());

    }

    DomainPeerServer domainPeerServer =

      new DomainPeerServer(domainSocketPath, port);

    domainPeerServer.setReceiveBufferSize(

        HdfsConstants.DEFAULT_DATA_SOCKET_SIZE);

    return domainPeerServer;

  }

 

  // calls specific to BP

  protected void notifyNamenodeReceivedBlock(

      ExtendedBlock block, String delHint, String storageUuid) {

    BPOfferService bpos = blockPoolManager.get(block.getBlockPoolId());

    if(bpos != null) {

      bpos.notifyNamenodeReceivedBlock(block, delHint, storageUuid);

    } else {

      LOG.error("Cannot find BPOfferService for reporting block received for bpid="

          + block.getBlockPoolId());

    }

  }

 

  // calls specific to BP

  protected void notifyNamenodeReceivingBlock(

      ExtendedBlock block, String storageUuid) {

    BPOfferService bpos = blockPoolManager.get(block.getBlockPoolId());

    if(bpos != null) {

      bpos.notifyNamenodeReceivingBlock(block, storageUuid);

    } else {

      LOG.error("Cannot find BPOfferService for reporting block receiving for bpid="

          + block.getBlockPoolId());

    }

  }

 

  /** Notify the corresponding namenode to delete the block. */

  public void notifyNamenodeDeletedBlock(ExtendedBlock block, String storageUuid) {

    BPOfferService bpos = blockPoolManager.get(block.getBlockPoolId());

    if (bpos != null) {

      bpos.notifyNamenodeDeletedBlock(block, storageUuid);

    } else {

      LOG.error("Cannot find BPOfferService for reporting block deleted for bpid="

          + block.getBlockPoolId());

    }

  }

 

  /**

   * Report a bad block which is hosted on the local DN.

   */

  public void reportBadBlocks(ExtendedBlock block) throws IOException{

    BPOfferService bpos = getBPOSForBlock(block);

    FsVolumeSpi volume = getFSDataset().getVolume(block);

    bpos.reportBadBlocks(

        block, volume.getStorageID(), volume.getStorageType());

  }

  /**

   * Report a bad block on another DN (eg if we received a corrupt replica

   * from a remote host).

   * @param srcDataNode the DN hosting the bad block

   * @param block the block itself

   */

  public void reportRemoteBadBlock(DatanodeInfo srcDataNode, ExtendedBlock block)

      throws IOException {

    BPOfferService bpos = getBPOSForBlock(block);

    bpos.reportRemoteBadBlock(srcDataNode, block);

  }

 

  /**

   * Try to send an error report to the NNs associated with the given

   * block pool.

   * @param bpid the block pool ID

   * @param errCode error code to send

   * @param errMsg textual message to send

   */

  void trySendErrorReport(String bpid, int errCode, String errMsg) {

    BPOfferService bpos = blockPoolManager.get(bpid);

    if (bpos == null) {

      throw new IllegalArgumentException("Bad block pool: " + bpid);

    }

    bpos.trySendErrorReport(errCode, errMsg);

  }

 

  /**

   * Return the BPOfferService instance corresponding to the given block.

   * @return the BPOS

   * @throws IOException if no such BPOS can be found

   */

  private BPOfferService getBPOSForBlock(ExtendedBlock block)

      throws IOException {

    Preconditions.checkNotNull(block);

    BPOfferService bpos = blockPoolManager.get(block.getBlockPoolId());

    if (bpos == null) {

      throw new IOException("cannot locate OfferService thread for bp="+

          block.getBlockPoolId());

    }

    return bpos;

  }

 

  // used only for testing

  void setHeartbeatsDisabledForTests(

      boolean heartbeatsDisabledForTests) {

    this.heartbeatsDisabledForTests = heartbeatsDisabledForTests;

  }

 

  boolean areHeartbeatsDisabledForTests() {

    return this.heartbeatsDisabledForTests;

  }

  /**

   * 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,

                     List<StorageLocation> dataDirs,

                    // DatanodeProtocol namenode,

                     SecureResources resources

                     ) throws IOException {

    if(UserGroupInformation.isSecurityEnabled() && resources == null) {

      if (!conf.getBoolean("ignore.secure.ports.for.testing", false)) {

        throw new RuntimeException("Cannot start secure cluster without "

            + "privileged resources.");

      }

    }

    // settings global for all BPs in the Data Node

    this.secureResources = resources;

    this.dataDirs = dataDirs;

    this.conf = conf;

    this.dnConf = new DNConf(conf);

    if (dnConf.maxLockedMemory > 0) {

      if (!NativeIO.POSIX.getCacheManipulator().verifyCanMlock()) {

        throw new RuntimeException(String.format(

            "Cannot start datanode because the configured max locked memory" +

            " size (%s) is greater than zero and native code is not available.",

            DFS_DATANODE_MAX_LOCKED_MEMORY_KEY));

      }

      long ulimit = NativeIO.POSIX.getCacheManipulator().getMemlockLimit();

      if (dnConf.maxLockedMemory > ulimit) {

      throw new RuntimeException(String.format(

          "Cannot start datanode because the configured max locked memory" +

          " size (%s) of %d bytes is more than the datanode's available" +

          " RLIMIT_MEMLOCK ulimit of %d bytes.",

          DFS_DATANODE_MAX_LOCKED_MEMORY_KEY,

          dnConf.maxLockedMemory,

          ulimit));

      }

    }

    LOG.info("Starting DataNode with maxLockedMemory = " +