执行start-dfs.sh脚本后，集群是如何启动的？
本文阅读并注释了start-dfs脚本，以及datanode的启动主要流程流程源码。

DataNode 启动流程

脚本代码分析

start-dfs.sh中启动datanode的代码：

#---------------------------------------------------------
# datanodes (using default workers file)

echo "Starting datanodes"
hadoop_uservar_su hdfs datanode "${HADOOP_HDFS_HOME}/bin/hdfs" 
    --workers 
    --config "${HADOOP_CONF_DIR}" 
    --daemon start 
    datanode ${dataStartOpt}
(( HADOOP_JUMBO_RETCOUNTER=HADOOP_JUMBO_RETCOUNTER + $? ))

去hadoop-hdfs > src > mian > bin > hdfs中查看namenode命令：

# 命令描述：用于启动DFS datanode
  hadoop_add_subcommand "datanode" daemon "run a DFS datanode"
  
# 命令处理程序
    datanode)
      HADOOP_SUBCMD_SUPPORTDAEMONIZATION="true"
      HADOOP_SECURE_CLASSNAME="org.apache.hadoop.hdfs.server.datanode.SecureDataNodeStarter"
      HADOOP_CLASSNAME="org.apache.hadoop.hdfs.server.datanode.DataNode"
      hadoop_deprecate_envvar HADOOP_SECURE_DN_PID_DIR HADOOP_SECURE_PID_DIR
      hadoop_deprecate_envvar HADOOP_SECURE_DN_LOG_DIR HADOOP_SECURE_LOG_DIR
    ;;

这里定位到了具体的处理类org.apache.hadoop.hdfs.server.datanode.SecureDataNodeStarter和org.apache.hadoop.hdfs.server.namenode.NameNode。

接着跟进脚本代码到hadoop-functions.sh中的hadoop_generic_java_subcmd_handler函数可以查看到以下代码：

  # do the hard work of launching a daemon or just executing our interactive
  #  是启动守护进程还是仅仅执行交互
  # java class
  if [[ "${HADOOP_SUBCMD_SUPPORTDAEMONIZATION}" = true ]]; then
    if [[ "${HADOOP_SUBCMD_SECURESERVICE}" = true ]]; then
      hadoop_secure_daemon_handler 
        "${HADOOP_DAEMON_MODE}" 
        "${HADOOP_SUBCMD}" 
        "${HADOOP_SECURE_CLASSNAME}" 
        "${daemon_pidfile}" 
        "${daemon_outfile}" 
        "${priv_pidfile}" 
        "${priv_outfile}" 
        "${priv_errfile}" 
        "${HADOOP_SUBCMD_ARGS[@]}"
    else
      hadoop_daemon_handler 
        "${HADOOP_DAEMON_MODE}" 
        "${HADOOP_SUBCMD}" 
        "${HADOOP_CLASSNAME}" 
        "${daemon_pidfile}" 
        "${daemon_outfile}" 
        "${HADOOP_SUBCMD_ARGS[@]}"
    fi
    exit $?
  else
    hadoop_java_exec "${HADOOP_SUBCMD}" "${HADOOP_CLASSNAME}" "${HADOOP_SUBCMD_ARGS[@]}"
  fi

这里需要分析一下最终走的是hadoop_secure_daemon_handler还是hadoop_daemon_handler。

在满足HADOOP_SUBCMD_SUPPORTDAEMONIZATION = true和HADOOP_SUBCMD_SECURESERVICE = true两个条件时才会进行安全模式启动。

HADOOP_SUBCMD_SUPPORTDAEMONIZATION在datanode的命令处理程序中会赋值：

# 在hdfs脚本中
datanode)
      HADOOP_SUBCMD_SUPPORTDAEMONIZATION="true"
         HADOOP_SECURE_CLASSNAME="org.apache.hadoop.hdfs.server.datanode.SecureDataNodeStarter"
# ......  
    ;;

HADOOP_SUBCMD_SECURESERVICE在hadoop-functions.sh脚本中定义的默认值为：

  HADOOP_SUBCMD_SECURESERVICE=false

在函数hadoop_generic_java_subcmd_handler（我们的脚本执行函数）中，有条件判断是否赋值为true：

## @description Handle subcommands from main program entries
## @audience private
## @stability evolving
## @replaceable yes
function hadoop_generic_java_subcmd_handler
{
# ......

  # The default/expected way to determine if a daemon is going to run in secure
  # mode is defined by hadoop_detect_priv_subcmd.  If this returns true
  # then setup the secure user var and tell the world we"re in secure mode

  if hadoop_detect_priv_subcmd "${HADOOP_SHELL_EXECNAME}" "${HADOOP_SUBCMD}"; then
    HADOOP_SUBCMD_SECURESERVICE=true
# ......

进入hadoop_detect_priv_subcmd函数中：

## @description autodetect whether this is a priv subcmd
## @description by whether or not a priv user var exists
## @description and if HADOOP_SECURE_CLASSNAME is defined
## @audience     public
## @stability    stable
## @replaceable  yes
## @param        command
## @param        subcommand
## @return       1 = not priv
## @return       0 = priv
function hadoop_detect_priv_subcmd
{
  declare program=$1
  declare command=$2
  # 
  if [[ -z "${HADOOP_SECURE_CLASSNAME}" ]]; then
    hadoop_debug "No secure classname defined."
    return 1
  fi

  uvar=$(hadoop_build_custom_subcmd_var "${program}" "${command}" SECURE_USER)
  if [[ -z "${!uvar}" ]]; then
    hadoop_debug "No secure user defined."
    return 1
  fi
  return 0
}

可以看到需要HADOOP_SECURE_CLASSNAME，和两个传入参数HADOOP_SHELL_EXECNAME,HADOOP_SUBCMD都存在的情况下才会返回0（在shell脚本中if function; then 格式，function返回0即会执行then后的语句）。

HADOOP_SECURE_CLASSNAME参数与HADOOP_SUBCMD_SUPPORTDAEMONIZATION相同会在hdfs脚本中的datanode的命令处理程序中赋值。

HADOOP_SHELL_EXECNAME参数在hdfs脚本中会定义默认值：

# The name of the script being executed.
HADOOP_SHELL_EXECNAME="hdfs"

HADOOP_SUBCMD参数在hdfs脚本中被定义为：HADOOP_SUBCMD=$1，即取自第二个参数，我们返回start-dfs.sh脚本中查看调用命令的完整语句如下：

#---------------------------------------------------------
# datanodes (using default workers file)

echo "Starting datanodes"
hadoop_uservar_su hdfs datanode "${HADOOP_HDFS_HOME}/bin/hdfs" 
    --workers 
    --config "${HADOOP_CONF_DIR}" 
    --daemon start 
    datanode ${dataStartOpt}
(( HADOOP_JUMBO_RETCOUNTER=HADOOP_JUMBO_RETCOUNTER + $? ))

第二个参数为workers。

所以可以得出，正常执行start-dfs.sh脚本的情况下，会默认值行hadoop_secure_daemon_handler函数，即通过执行SecureDataNodeStarter类来以安全模式启动datanode。

SecureDataNodeStarter

官方注释翻译:

在安全集群中启动datanode的实用程序类，首先在主启动前获得特权资源并将它们交给datanode。

SecureDataNodeStarter实现了Daemon，作为一个守护进程，我们先看它实现自Daemon的方法：

  @Override
  public void init(DaemonContext context) throws Exception {
    System.err.println("Initializing secure datanode resources");
    // 创建一个新的HdfsConfiguration对象，以确保选中hdfs-site.xml中的配置。
    Configuration conf = new HdfsConfiguration();
    
    // 存储常规datanode的命令行参数
    args = context.getArguments();
    // 初始化数据节点的特权资源(即特权端口)。
    resources = getSecureResources(conf);
  }

 @Override
  public void start() throws Exception {
    System.err.println("Starting regular datanode initialization");
    // 正常的初始化DataNode
    DataNode.secureMain(args, resources);
  }

  @Override public void destroy() {}
  @Override public void stop() throws Exception {  }

静态变量

可以看到SecureDataNodeStarter主要作用就是获取配置信息并存储起来，然后正常的初始化DateNode时再作为参数传递。接下来看看除了命令行参数外都还初始化了哪些参数：

	// 命令行参数
  private String [] args;
  private SecureResources resources;

	// 在安全的环境中存储datanode操作所需的资源
	public static class SecureResources {
    // 是否启用sasl
    private final boolean isSaslEnabled;
    // rpc 端口是否为特权端口（端口号小于1024，不允许普通用户在其上运行服务器）
    // 详见https://www.w3.org/Daemon/User/Installation/PrivilegedPorts.html
    private final boolean isRpcPortPrivileged;
    // http 端口是否为特权端口
    private final boolean isHttpPortPrivileged;
		
  	// 监听dfs.datanode.address配置的端口的服务器套接字
    private final ServerSocket streamingSocket;
  	// 监听dfs.datanode.http.address配置的端口的服务器套接字通道
    private final ServerSocketChannel httpServerSocket;

    public SecureResources(ServerSocket streamingSocket, ServerSocketChannel
        httpServerSocket, boolean saslEnabled, boolean rpcPortPrivileged,
        boolean httpPortPrivileged) {
      this.streamingSocket = streamingSocket;
      this.httpServerSocket = httpServerSocket;
      this.isSaslEnabled = saslEnabled;
      this.isRpcPortPrivileged = rpcPortPrivileged;
      this.isHttpPortPrivileged = httpPortPrivileged;
    }

   // getter / setter .... 略
  }

getSecureResources(conf)

接下来看init()中调用的方法getSecureResources(conf)，看看SecureResources中的参数都是从哪获取的。

  //  获取数据节点的特权资源(即特权端口)。
  //  特权资源由RPC服务器的端口和HTTP(不是HTTPS)服务器的端口组成。
  @VisibleForTesting
  public static SecureResources getSecureResources(Configuration conf)
      throws Exception {
    // 获取http访问协议，HTTP_ONLY, HTTPS_ONLY, HTTP_AND_HTTPS
    HttpConfig.Policy policy = DFSUtil.getHttpPolicy(conf);
    // 尝试构建SaslPropertiesResolver，如果可以即为开启sasl
    boolean isSaslEnabled =
        DataTransferSaslUtil.getSaslPropertiesResolver(conf) != null;
    boolean isRpcPrivileged;
    boolean isHttpPrivileged = false;

    System.err.println("isSaslEnabled:" + isSaslEnabled);
    // 获取数据流到datanode的安全端口，创建IP套接字地址
    // 会通过配置项dfs.datanode.address来创建，配置的默认值为：0.0.0.0:9866
    InetSocketAddress streamingAddr  = DataNode.getStreamingAddr(conf);
    // 获取socket 写超时时间
    // 配置项为:dfs.datanode.socket.write.timeout, 默认值为：8 * 60 秒
    int socketWriteTimeout = conf.getInt(
        DFSConfigKeys.DFS_DATANODE_SOCKET_WRITE_TIMEOUT_KEY,
        HdfsConstants.WRITE_TIMEOUT);
    // 获取请求的传入连接队列的最大长度。
    // 配置项为ipc.server.listen.queue.size， 默认值为256
    int backlogLength = conf.getInt(
        CommonConfigurationKeysPublic.IPC_SERVER_LISTEN_QUEUE_SIZE_KEY,
        CommonConfigurationKeysPublic.IPC_SERVER_LISTEN_QUEUE_SIZE_DEFAULT);
    // 默认打开ServerSocketChannel进行datanode端口监听
    ServerSocket ss = (socketWriteTimeout > 0) ?
        ServerSocketChannel.open().socket() : new ServerSocket();
    try {
      // 绑定端口，设置请求的传入连接队列的最大长度
      ss.bind(streamingAddr, backlogLength);
    } catch (BindException e) {
      BindException newBe = appendMessageToBindException(e,
          streamingAddr.toString());
      throw newBe;
    }

    // 检查是否绑定到了正确
    if (ss.getLocalPort() != streamingAddr.getPort()) {
      throw new RuntimeException(
          "Unable to bind on specified streaming port in secure "
              + "context. Needed " + streamingAddr.getPort() + ", got "
              + ss.getLocalPort());
    }

    // 检查给定端口是否为特权端口。
    // 在unix/linux系统中，小于1024的端口被视为特权端口。
    // 对于其他操作系统，请谨慎使用此方法。
    // 例如，Windows没有特权端口的概念。
    // 但是，在Windows客户端上可以用来检查linux服务器的端口。
    isRpcPrivileged = SecurityUtil.isPrivilegedPort(ss.getLocalPort());
    System.err.println("Opened streaming server at " + streamingAddr);

    //  为web服务器绑定端口。
    //  该代码打算仅将HTTP服务器绑定到特权端口，因为如果服务器通过SSL进行通信，客户端可以使用证书对服务器进行身份验证。
    final ServerSocketChannel httpChannel;
    // 判断是否允许http访问
    if (policy.isHttpEnabled()) {
      httpChannel = ServerSocketChannel.open();
      // 确定http服务器的有效地址
      // 通过配置项dfs.datanode.http.address来生成，默认值为：0.0.0.0:9864
      InetSocketAddress infoSocAddr = DataNode.getInfoAddr(conf);
      try {
        httpChannel.socket().bind(infoSocAddr);
      } catch (BindException e) {
        BindException newBe = appendMessageToBindException(e,
            infoSocAddr.toString());
        throw newBe;
      }
      InetSocketAddress localAddr = (InetSocketAddress) httpChannel.socket()
        .getLocalSocketAddress();
      // 校验httpChannel绑定的地址是否正确
      if (localAddr.getPort() != infoSocAddr.getPort()) {
        throw new RuntimeException("Unable to bind on specified info port in " +
            "secure context. Needed " + infoSocAddr.getPort() + ", got " +
             ss.getLocalPort());
      }
      System.err.println("Successfully obtained privileged resources (streaming port = "
          + ss + " ) (http listener port = " + localAddr.getPort() +")");
      // 判断端口号是否为特权端口（小于1024）
      isHttpPrivileged = SecurityUtil.isPrivilegedPort(localAddr.getPort());
      System.err.println("Opened info server at " + infoSocAddr);
    } else {
      httpChannel = null;
    }
    // 将获取到的特权资源封装成SecureResources
    return new SecureResources(ss, httpChannel, isSaslEnabled,
        isRpcPrivileged, isHttpPrivileged);
  }

至此，SecureDataNodeStarter类的init()方法结束。

继续看start()方法，可以看到就是正常的传入init()方法中初始化的配置。

  @Override
  public void start() throws Exception {
    System.err.println("Starting regular datanode initialization");
    DataNode.secureMain(args, resources);
  }

resources参数在datanode中的具体作用见datanode代码分析

DataNode

dataNode官方注释反应如下：

DataNode是一个类(和程序)，它为DFS部署存储一组块。
单个部署可以有一个或多个datanode。
每个DataNode定期与单个NameNode通信。
它还会不时地与客户机代码和其他datanode通信。
datanode存储一系列命名块。
DataNode允许客户端代码读取这些块，或者写入新的块数据。
DataNode也可以响应来自它的NameNode的指令，删除块或从其他DataNode复制块。
DataNode只维护一个关键表:block->这个信息存储在本地磁盘上。
DataNode会在启动时以及之后的每隔一段时间向NameNode报告表的内容。
datanode一辈子都在无止境地要求NameNode做点什么。
NameNode不能直接连接到DataNode;NameNode只是从DataNode调用的函数中返回值。
datanode维护一个开放的服务器套接字，以便客户端代码或其他datanode可以读写数据。
这个服务器的主机/端口报告给NameNode，然后NameNode将该信息发送给可能感兴趣的客户端或其他datanode。

静态代码块

dataNode的静态代码块与NameNode中相同，用于加载默认的配置文件

  static{
    HdfsConfiguration.init();
  }

mian方法

由上文中SecureDataNodeStarter#start方法可以看到，默认调用的是DataNode#secureMain方法来启动datanode。而默认的main方法也是调用DataNode#secureMain，接下来具体看看main和secureMain方法的代码：

  public static void main(String args[]) {
    // 分析传入的参数，是否是帮助参数
    if (DFSUtil.parseHelpArgument(args, DataNode.USAGE, System.out, true)) {
      System.exit(0);
    }
		// 调用
    secureMain(args, null);
  }

  public static void secureMain(String args[], SecureResources resources) {
    int errorCode = 0;
    try {
      //打印一些启动日志信息
      StringUtils.startupShutdownMessage(DataNode.class, args, LOG);
      // 创建datanode
      DataNode datanode = createDataNode(args, null, resources);
      if (datanode != null) {
        // join各种线程，等待执行结束
        // blockPoolManager.joinAll(); -> BPOfferService#jion -> BPServiceActor#join
        // BPServiceActor: 每个活动或备用namenode要执行的线程:
        // 预注册与namenode握手, 然后登记, 定期发送心跳到namenode, 处理从namenode接收到的命令
        datanode.join();
      } else {
        errorCode = 1;
      }
    } catch (Throwable e) {
      LOG.error("Exception in secureMain", e);
      terminate(1, e);
    } finally {
      // We need to terminate the process here because either shutdown was called
      // or some disk related conditions like volumes tolerated or volumes required
      // condition was not met. Also, In secure mode, control will go to Jsvc
      // and Datanode process hangs if it does not exit.
      LOG.warn("Exiting Datanode");
      terminate(errorCode);
    }
  }

DataNode#createDataNode

实例化&启动一个datanode守护进程并等待它完成。

  @VisibleForTesting
  @InterfaceAudience.Private
  public static DataNode createDataNode(String args[], Configuration conf,
      SecureResources resources) throws IOException {
    // 初始化datanode
    DataNode dn = instantiateDataNode(args, conf, resources);
    if (dn != null) {
      // 启动datanode进程
      dn.runDatanodeDaemon();
    }
    return dn;
  }

先来看看初始化datanode的流程：

DataNode#instantiateDataNode

// 实例化单个datanode对象及其安全资源。这必须通过随后调用datanodedaemon()来运行。
public static DataNode instantiateDataNode(String args [], Configuration conf,
    SecureResources resources) throws IOException {
  if (conf == null)
    conf = new HdfsConfiguration();
  
  if (args != null) {
    // 解析通用hadoop选项
    GenericOptionsParser hParser = new GenericOptionsParser(conf, args);
    args = hParser.getRemainingArgs();
  }
  // 解析和验证命令行参数并设置配置参数。
  if (!parseArguments(args, conf)) {
    printUsage(System.err);
    return null;
  }
  // 根据配置dfs.datanode.data.dir 获取实际的存储路径集合
  // StorageLocation: 封装描述存储目录的URI和存储介质。如果没有指定存储介质，则假定默认存储介质为DISK。
  // 详细的关于获取存储目录的解析看这篇博文： https://blog.csdn.net/Androidlushangderen/article/details/51105876
  Collection dataLocations = getStorageLocations(conf);
  // UserGroupInformation: Hadoop的用户和组信息。
  // 该类封装了一个JAAS Subject，并提供了确定用户用户名和组的方法。
  // 它同时支持Windows、Unix和Kerberos登录模块。
  // UserGroupInformation#setConfiguration: 设置UGI的静态配置。特别是设置安全身份验证机制和组查找服务。
  UserGroupInformation.setConfiguration(conf);
  // 作为config中指定的主体登录。将用户的Kerberos主体名中的$host替换为主机名。 如果是非安全模式-返回。
  SecurityUtil.login(conf, DFS_DATANODE_KEYTAB_FILE_KEY,
      DFS_DATANODE_KERBEROS_PRINCIPAL_KEY, getHostName(conf));
  // 创建DataNode实例
  return makeInstance(dataLocations, conf, resources);
}

DataNode#makeInstance

// 在确保可以创建至少一个给定的数据目录(以及它们的父目录，如果需要的话)之后，创建DataNode实例。
static DataNode makeInstance(Collection dataDirs,
    Configuration conf, SecureResources resources) throws IOException {
  List locations;
  //  StorageLocationChecker: 在DataNode启动期间封装存储位置检查的实用程序类。其中一些代码是从DataNode类中提取的。
  StorageLocationChecker storageLocationChecker =
      new StorageLocationChecker(conf, new Timer());
  try {
    // 启动对提供的存储卷的检查，并返回运行正常的卷列表。
    // 为了与现有单元测试兼容，storagellocations将按照与输入相同的顺序返回。
    locations = storageLocationChecker.check(conf, dataDirs);
  } catch (InterruptedException ie) {
    throw new IOException("Failed to instantiate DataNode", ie);
  }
  // 初始化度量系统
  DefaultMetricsSystem.initialize("DataNode");
  // 检查数据目录的权限
  assert locations.size() > 0 : "number of data directories should be > 0";
  // 创建DataNode
  return new DataNode(conf, locations, storageLocationChecker, resources);
}

StorageLocationChecker#check

来具体看一下都做了哪些检查：

  // 启动对提供的存储卷的检查，并返回运行正常的卷列表。
  // 为了与现有单元测试兼容，storagellocations将按照与输入相同的顺序返回。
  // 返回运行正常的卷列表。如果没有正常运行的卷，则返回一个空列表。
  public List check(
      final Configuration conf,
      final Collection dataDirs)
      throws InterruptedException, IOException {

    final HashMap goodLocations =
        new LinkedHashMap<>();
    final Set failedLocations = new HashSet<>();
    final Map> futures =
        Maps.newHashMap();
    // 获取本地文件系统。如果没有就创建一个新的
    final LocalFileSystem localFS = FileSystem.getLocal(conf);
    final CheckContext context = new CheckContext(localFS, expectedPermission);

    // 在所有storagelocation上启动并行磁盘检查操作。
    for (StorageLocation location : dataDirs) {
      goodLocations.put(location, true);
      // 对给定的Checkable安排异步检查。如果检查计划成功，则返回ListenableFuture。
      Optional> olf =
          delegateChecker.schedule(location, context);
      if (olf.isPresent()) {
        futures.put(location, olf.get());
      }
    }

    if (maxVolumeFailuresTolerated >= dataDirs.size()) {
      throw new HadoopIllegalArgumentException("Invalid value configured for "
          + DFS_DATANODE_FAILED_VOLUMES_TOLERATED_KEY + " - "
          + maxVolumeFailuresTolerated + ". Value configured is >= "
          + "to the number of configured volumes (" + dataDirs.size() + ").");
    }

    final long checkStartTimeMs = timer.monotonicNow();

    // Retrieve the results of the disk checks.
    // 检索磁盘，检查磁盘状态是否健康
    for (Map.Entry> entry : futures.entrySet()) {

      // Determine how much time we can allow for this check to complete.
      // The cumulative wait time cannot exceed maxAllowedTimeForCheck.
      final long waitSoFarMs = (timer.monotonicNow() - checkStartTimeMs);
      final long timeLeftMs = Math.max(0,
          maxAllowedTimeForCheckMs - waitSoFarMs);
      final StorageLocation location = entry.getKey();

      try {
        final VolumeCheckResult result =
            entry.getValue().get(timeLeftMs, TimeUnit.MILLISECONDS);
        switch (result) {
        case HEALTHY:
          break;
        case DEGRADED:
          LOG.warn("StorageLocation {} appears to be degraded.", location);
          break;
        case FAILED:
          LOG.warn("StorageLocation {} detected as failed.", location);
          failedLocations.add(location);
          goodLocations.remove(location);
          break;
        default:
          LOG.error("Unexpected health check result {} for StorageLocation {}",
              result, location);
        }
      } catch (ExecutionException|TimeoutException e) {
        LOG.warn("Exception checking StorageLocation " + location,
            e.getCause());
        failedLocations.add(location);
        goodLocations.remove(location);
      }
    }

    if (maxVolumeFailuresTolerated == DataNode.MAX_VOLUME_FAILURE_TOLERATED_LIMIT) {
      if (dataDirs.size() == failedLocations.size()) {
        throw new DiskErrorException("Too many failed volumes - "
            + "current valid volumes: " + goodLocations.size()
            + ", volumes configured: " + dataDirs.size()
            + ", volumes failed: " + failedLocations.size()
            + ", volume failures tolerated: " + maxVolumeFailuresTolerated);
      }
    } else {
      if (failedLocations.size() > maxVolumeFailuresTolerated) {
        throw new DiskErrorException("Too many failed volumes - "
            + "current valid volumes: " + goodLocations.size()
            + ", volumes configured: " + dataDirs.size()
            + ", volumes failed: " + failedLocations.size()
            + ", volume failures tolerated: " + maxVolumeFailuresTolerated);
      }
    }

    if (goodLocations.size() == 0) {
      throw new DiskErrorException("All directories in "
          + DFS_DATANODE_DATA_DIR_KEY + " are invalid: "
          + failedLocations);
    }

    return new ArrayList<>(goodLocations.keySet());
  }

DataNode构造方法

// 给定一个配置、一个datadir数组和一个namenode代理，创建DataNode。
  DataNode(final Configuration conf,
           final List dataDirs,
           final StorageLocationChecker storageLocationChecker,
           final SecureResources resources) throws IOException {
    // 将配置文件赋值到父类的静态变量中
    super(conf);
    // 初始化Tracer，与NameNode中此处相比，仅传入参数有区别
    this.tracer = createTracer(conf);
    // TracerConfigurationManager类提供了通过RPC协议在运行时管理跟踪器配置的函数。
    this.tracerConfigurationManager =
        new TracerConfigurationManager(DATANODE_HTRACE_PREFIX, conf);
    // FileIoProvider这个类抽象出DataNode执行的各种文件IO操作，
    // 并在每个文件IO之前和之后调用概要分析(用于收集统计数据)和故障注入(用于测试)事件钩子。
    // 通过DFSConfigKeys启用剖析和/或错误注入事件钩子，可以将行为注入到这些事件中。
    this.fileIoProvider = new FileIoProvider(conf, this);
    // 初始化卷扫描，BlockScanner负责管理所有的VolumeScanner
    this.blockScanner = new BlockScanner(this);
    // 初始化各种配置参数
    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.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);
    this.pipelineSupportECN = conf.getBoolean(
        DFSConfigKeys.DFS_PIPELINE_ECN_ENABLED,
        DFSConfigKeys.DFS_PIPELINE_ECN_ENABLED_DEFAULT);

    confVersion = "core-" +
        conf.get("hadoop.common.configuration.version", "UNSPECIFIED") +
        ",hdfs-" +
        conf.get("hadoop.hdfs.configuration.version", "UNSPECIFIED");
    // DatasetVolumeChecker： 对FsDatasetSpi的每个卷封装运行磁盘检查的类，并允许检索失败卷的列表。
    // 这分离了最初跨DataNode、FsDatasetImpl和FsVolumeList实现的行为。
    this.volumeChecker = new DatasetVolumeChecker(conf, new Timer());
    // 创建了个ExecutorService，用于执行dataTransfer任务
    // HadoopExecutors：ExecutorService、ScheduledExecutorService实例的工厂方法。这些执行器服务实例提供了额外的功能(例如记录未捕获的异常)。
    // DataTransfer：是DataNode的内部类，用于传输一个数据块。这个类将一条数据发送到另一个DataNode。
    this.xferService =
        HadoopExecutors.newCachedThreadPool(new Daemon.DaemonFactory());

    // Determine whether we should try to pass file descriptors to clients.
    // 确定是否应该尝试将文件描述符传递给客户端。
    if (conf.getBoolean(HdfsClientConfigKeys.Read.ShortCircuit.KEY,
              HdfsClientConfigKeys.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);
    }
    // 获取socket工厂，配置项为：hadoop.rpc.socket.factory.class.default，
    // 默认为：org.apache.hadoop.net.StandardSocketFactory
    this.socketFactory = NetUtils.getDefaultSocketFactory(conf);

    try {
      // 获取本datanode的主机名
      hostName = getHostName(conf);
      LOG.info("Configured hostname is {}", hostName);
      // 启动datanode
      startDataNode(dataDirs, resources);
    } catch (IOException ie) {
      shutdown();
      throw ie;
    }
    final int dncCacheMaxSize =
        conf.getInt(DFS_DATANODE_NETWORK_COUNTS_CACHE_MAX_SIZE_KEY,
            DFS_DATANODE_NETWORK_COUNTS_CACHE_MAX_SIZE_DEFAULT) ;
    datanodeNetworkCounts =
        CacheBuilder.newBuilder()
            .maximumSize(dncCacheMaxSize)
            .build(new CacheLoader>() {
              @Override
              public Map load(String key) throws Exception {
                final Map ret = new HashMap();
                ret.put("networkErrors", 0L);
                return ret;
              }
            });

    initOOBTimeout();
    this.storageLocationChecker = storageLocationChecker;
  }

DataNode#startDataNode

// 此方法使用指定的conf启动数据节点，如果设置了conf的config_property_simulation属性，则创建一个模拟的基于存储的数据节点
void startDataNode(List dataDirectories,
                   SecureResources resources
                   ) throws IOException {

  // settings global for all BPs in the Data Node
  this.secureResources = resources;
  synchronized (this) {
    this.dataDirs = dataDirectories;
  }
  // DNConf: 一个简单的类，封装了DataNode在启动时加载的所有配置。
  this.dnConf = new DNConf(this);
  // 检查secure模式下的配置
  checkSecureConfig(dnConf, getConf(), resources);
  // 检查DataNode给缓存使用的最大内存量是否在正常范围
  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));
    }
    if (Path.WINDOWS) {
      NativeIO.Windows.extendWorkingSetSize(dnConf.maxLockedMemory);
    } else {
      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 = {}",
      dnConf.maxLockedMemory);

  int volFailuresTolerated = dnConf.getVolFailuresTolerated();
  int volsConfigured = dnConf.getVolsConfigured();
  if (volFailuresTolerated < MAX_VOLUME_FAILURE_TOLERATED_LIMIT
      || volFailuresTolerated >= volsConfigured) {
    throw new HadoopIllegalArgumentException("Invalid value configured for "
        + "dfs.datanode.failed.volumes.tolerated - " + volFailuresTolerated
        + ". Value configured is either less than -1 or >= "
        + "to the number of configured volumes (" + volsConfigured + ").");
  }
  // 初始化DataStorage：数据存储信息文件。
  // 本地存储信息存储在一个单独的文件VERSION中。
  // 包含节点类型、存储布局版本、命名空间id、fs状态创建时间。
  // 本地存储可以位于多个目录中。每个目录应该包含与其他目录相同的VERSION文件。
  // 在启动期间Hadoop服务器(name-node和data-node)从它们读取本地存储信息。
  // 服务器在运行时对每个存储目录持有一个锁，这样其他节点就不能在启动时共享相同的存储。
  // 当服务器停止(正常或异常)时，锁将被释放。
  storage = new DataStorage();
  
  // global DN settings
  // 注册JMX，JMX介绍看着篇： https://www.liaoxuefeng.com/wiki/1252599548343744/1282385687609378
  registerMXBean();
  // 初始化DataXceiver（流式通信），DataNode runDatanodeDaemon()中启动
  initDataXceiver();
  // 启动InfoServer
  startInfoServer();
  // 启动JVMPauseMonitor（反向监控JVM情况，可通过JMX查询）
  pauseMonitor = new JvmPauseMonitor();
  pauseMonitor.init(getConf());
  pauseMonitor.start();

  // BlockPoolTokenSecretManager is required to create ipc server.
  //  BlockPoolTokenSecretManager: 管理每个块池的BlockTokenSecretManager。将给定块池Id的请求路由到相应的BlockTokenSecretManager
  this.blockPoolTokenSecretManager = new BlockPoolTokenSecretManager();

  // Login is done by now. Set the DN user name.
  dnUserName = UserGroupInformation.getCurrentUser().getUserName();
  LOG.info("dnUserName = {}", dnUserName);
  LOG.info("supergroup = {}", supergroup);
  // 初始化IpcServer（RPC通信），DataNode-runDatanodeDaemon()中启动
  initIpcServer();

  metrics = DataNodeMetrics.create(getConf(), getDisplayName());
  peerMetrics = dnConf.peerStatsEnabled ?
      DataNodePeerMetrics.create(getDisplayName(), getConf()) : null;
  metrics.getJvmMetrics().setPauseMonitor(pauseMonitor);

  ecWorker = new ErasureCodingWorker(getConf(), this);
  blockRecoveryWorker = new BlockRecoveryWorker(this);
  // 按照namespace（nameservice）、namenode的结构进行初始化
  blockPoolManager = new BlockPoolManager(this);
  // 心跳管理
  blockPoolManager.refreshNamenodes(getConf());

  // Create the ReadaheadPool from the DataNode context so we can
  // exit without having to explicitly shutdown its thread pool.
  readaheadPool = ReadaheadPool.getInstance();
  saslClient = new SaslDataTransferClient(dnConf.getConf(),
      dnConf.saslPropsResolver, dnConf.trustedChannelResolver);
  saslServer = new SaslDataTransferServer(dnConf, blockPoolTokenSecretManager);
  startMetricsLogger();

  if (dnConf.diskStatsEnabled) {
    diskMetrics = new DataNodeDiskMetrics(this,
        dnConf.outliersReportIntervalMs);
  }
}

DataNode#checkSecureConfig

先看看checkSecureConfig(dnConf, getConf(), resources);方法具体检测了什么，又如何使用了传入的resource参数：

// 如果启用了安全性，检查DataNode是否有安全配置。有两种可能的配置是安全的:
// 1. 服务器已经通过SecureDataNodeStarter绑定到RPC和HTTP的特权端口。
// 2. 该配置对HTTP服务器的DataTransferProtocol和HTTPS(无明文HTTP)启用SASL。
// SASL握手保证了RPC服务器在客户端传输一个秘密(比如块访问令牌)之前的身份验证。
// 类似地，SSL在客户端传输秘密(比如委托令牌)之前保证HTTP服务器的身份验证。

// 不可能同时在DataTransferProtocol上运行特权端口和SASL。
// 为了向后兼容，连接逻辑必须检查目标端口是否为特权端口，如果是，跳过SASL握手。
private static void checkSecureConfig(DNConf dnConf, Configuration conf,
    SecureResources resources) throws RuntimeException {
  if (!UserGroupInformation.isSecurityEnabled()) {
    return;
  }

  // Abort out of inconsistent state if Kerberos is enabled but block access tokens are not enabled.
  // 如果启用了Kerberos，但没有启用块访问令牌，则退出不一致状态
  boolean isEnabled = conf.getBoolean(
      DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_ENABLE_KEY,
      DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_ENABLE_DEFAULT);
  if (!isEnabled) {
    String errMessage = "Security is enabled but block access tokens " +
        "(via " + DFSConfigKeys.DFS_BLOCK_ACCESS_TOKEN_ENABLE_KEY + ") " +
        "aren"t enabled. This may cause issues " +
        "when clients attempt to connect to a DataNode. Aborting DataNode";
    throw new RuntimeException(errMessage);
  }
  // 如果配置设置为跳过安全集群中正确端口配置的检查，则返回true。这只用于开发测试。
  if (dnConf.getIgnoreSecurePortsForTesting()) {
    return;
  }

  if (resources != null) {
    // 特权端口或配置HTTPS_ONLY
    final boolean httpSecured = resources.isHttpPortPrivileged()
        || DFSUtil.getHttpPolicy(conf) == HttpConfig.Policy.HTTPS_ONLY;
    // 特权端口或配置开启sasl
    final boolean rpcSecured = resources.isRpcPortPrivileged()
        || resources.isSaslEnabled();

    // Allow secure DataNode to startup if:
    // 1. Http is secure.
    // 2. Rpc is secure
    if (rpcSecured && httpSecured) {
      return;
    }
  } else {
    // Handle cases when SecureDataNodeStarter#getSecureResources is not invoked
    // 处理SecureDataNodeStarter#getSecureResources未被调用的情况
    SaslPropertiesResolver saslPropsResolver = dnConf.getSaslPropsResolver();
    if (saslPropsResolver != null &&
        DFSUtil.getHttpPolicy(conf) == HttpConfig.Policy.HTTPS_ONLY) {
      return;
    }
  }

  throw new RuntimeException("Cannot start secure DataNode due to incorrect "
      + "config. See https://cwiki.apache.org/confluence/display/HADOOP/"
      + "Secure+DataNode for details.");
}

DataNode#initDataXceiver

private void initDataXceiver() throws IOException {
    // find free port or use privileged port provided
    TcpPeerServer tcpPeerServer;
    if (secureResources != null) {
      // 通过secureResources中的streamingSocket创建TcpPeerServer
      tcpPeerServer = new TcpPeerServer(secureResources);
    } else {
      int backlogLength = getConf().getInt(
          CommonConfigurationKeysPublic.IPC_SERVER_LISTEN_QUEUE_SIZE_KEY,
          CommonConfigurationKeysPublic.IPC_SERVER_LISTEN_QUEUE_SIZE_DEFAULT);
      tcpPeerServer = new TcpPeerServer(dnConf.socketWriteTimeout,
          DataNode.getStreamingAddr(getConf()), backlogLength);
    }
    if (dnConf.getTransferSocketRecvBufferSize() > 0) {
      tcpPeerServer.setReceiveBufferSize(
          dnConf.getTransferSocketRecvBufferSize());
    }
    streamingAddr = tcpPeerServer.getStreamingAddr();
    LOG.info("Opened streaming server at {}", streamingAddr);
    // 构造一个新的线程组。这个新组的父线程组是当前运行线程的线程组。
    this.threadGroup = new ThreadGroup("dataXceiverServer");
    // DataXceiverServer: 用于接收/发送数据块的服务器。
    // 创建它是为了侦听来自客户端或其他datanode的请求。这个小服务器不使用Hadoop IPC机制。
    xserver = new DataXceiverServer(tcpPeerServer, getConf(), this);
    // DN用来接收客户端和其他DN发送过来的数据服务,并为每个请求创建一个工作线程以进行请求的响应
    this.dataXceiverServer = new Daemon(threadGroup, xserver);
    this.threadGroup.setDaemon(true); // auto destroy when empty

    if (getConf().getBoolean(
        HdfsClientConfigKeys.Read.ShortCircuit.KEY,
        HdfsClientConfigKeys.Read.ShortCircuit.DEFAULT) ||
        getConf().getBoolean(
            HdfsClientConfigKeys.DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC,
            HdfsClientConfigKeys
              .DFS_CLIENT_DOMAIN_SOCKET_DATA_TRAFFIC_DEFAULT)) {
      DomainPeerServer domainPeerServer =
                getDomainPeerServer(getConf(), streamingAddr.getPort());
      if (domainPeerServer != null) {
        this.localDataXceiverServer = new Daemon(threadGroup,
            new DataXceiverServer(domainPeerServer, getConf(), this));
        LOG.info("Listening on UNIX domain socket: {}",
            domainPeerServer.getBindPath());
      }
    }
    this.shortCircuitRegistry = new ShortCircuitRegistry(getConf());
  }

DataNode#createDataNode

接着回到DataNode#createDataNode方法中，继续看启动datanode的流程dn.runDatanodeDaemon();：

  public void runDatanodeDaemon() throws IOException {
    blockPoolManager.startAll();

    // start dataXceiveServer
    dataXceiverServer.start();
    if (localDataXceiverServer != null) {
      localDataXceiverServer.start();
    }
    ipcServer.setTracer(tracer);
    ipcServer.start();
    startPlugins(getConf());
  }