public void start()

in hadoop-hdds/container-service/src/main/java/org/apache/hadoop/ozone/HddsDatanodeService.java [207:347]
116 lines of code
12 McCabe index (conditional complexity)

  public void start() {
    serviceRuntimeInfo = new DNMXBeanImpl(HddsVersionInfo.HDDS_VERSION_INFO) {
      @Override
      public String getNamespace() {
        return HddsUtils.getScmServiceId(conf);
      }
    };
    serviceRuntimeInfo.setStartTime();

    ratisReporterList = RatisDropwizardExports
        .registerRatisMetricReporters(ratisMetricsMap, () -> isStopped.get());

    OzoneConfiguration.activate();
    HddsServerUtil.initializeMetrics(conf, "HddsDatanode");
    try {
      String hostname = HddsUtils.getHostName(conf);
      datanodeDetails = initializeDatanodeDetails();
      datanodeDetails.setHostName(hostname);
      serviceRuntimeInfo.setHostName(hostname);
      datanodeDetails.validateDatanodeIpAddress();
      datanodeDetails.setVersion(
          HddsVersionInfo.HDDS_VERSION_INFO.getVersion());
      datanodeDetails.setSetupTime(Time.now());
      datanodeDetails.setRevision(
          HddsVersionInfo.HDDS_VERSION_INFO.getRevision());
      TracingUtil.initTracing(
          "HddsDatanodeService." + datanodeDetails.getID(), conf);
      LOG.info("HddsDatanodeService {}", datanodeDetails);
      // Authenticate Hdds Datanode service if security is enabled
      if (OzoneSecurityUtil.isSecurityEnabled(conf)) {
        component = "dn-" + datanodeDetails.getID();
        secConf = new SecurityConfig(conf);

        if (SecurityUtil.getAuthenticationMethod(conf).equals(
            UserGroupInformation.AuthenticationMethod.KERBEROS)) {
          LOG.info("Ozone security is enabled. Attempting login for Hdds " +
                  "Datanode user. Principal: {},keytab: {}", conf.get(
                  HddsConfigKeys.HDDS_DATANODE_KERBEROS_PRINCIPAL_KEY),
              conf.get(
                  HddsConfigKeys.HDDS_DATANODE_KERBEROS_KEYTAB_FILE_KEY));

          UserGroupInformation.setConfiguration(conf);

          SecurityUtil
              .login(conf,
                  HddsConfigKeys.HDDS_DATANODE_KERBEROS_KEYTAB_FILE_KEY,
                  HddsConfigKeys.HDDS_DATANODE_KERBEROS_PRINCIPAL_KEY,
                  hostname);
        } else {
          throw new AuthenticationException(SecurityUtil.
              getAuthenticationMethod(conf) + " authentication method not " +
              "supported. Datanode user" + " login " + "failed.");
        }
        LOG.info("Hdds Datanode login successful.");
      }

      DatanodeLayoutStorage layoutStorage = new DatanodeLayoutStorage(conf,
          datanodeDetails.getUuidString());
      if (layoutStorage.getState() != INITIALIZED) {
        layoutStorage.initialize();
      }

      if (OzoneSecurityUtil.isSecurityEnabled(conf)) {
        dnCertClient = initializeCertificateClient(dnCertClient);

        if (secConf.isTokenEnabled()) {
          SecretKeyProtocol secretKeyProtocol =
              HddsServerUtil.getSecretKeyClientForDatanode(conf);
          secretKeyClient = DefaultSecretKeyClient.create(
              conf, secretKeyProtocol, "");
          secretKeyClient.start(conf);
        }
      }

      reconfigurationHandler =
          new ReconfigurationHandler("DN", conf, this::checkAdminPrivilege)
              .register(HDDS_DATANODE_BLOCK_DELETE_THREAD_MAX,
                  this::reconfigBlockDeleteThreadMax)
              .register(OZONE_BLOCK_DELETING_SERVICE_WORKERS,
                  this::reconfigDeletingServiceWorkers)
              .register(REPLICATION_STREAMS_LIMIT_KEY,
                  this::reconfigReplicationStreamsLimit);

      datanodeStateMachine = new DatanodeStateMachine(this, datanodeDetails, conf,
          dnCertClient, secretKeyClient, this::terminateDatanode,
          reconfigurationHandler);
      try {
        httpServer = new HddsDatanodeHttpServer(conf);
        httpServer.start();
        HttpConfig.Policy policy = HttpConfig.getHttpPolicy(conf);

        if (policy.isHttpEnabled()) {
          int httpPort = httpServer.getHttpAddress().getPort();
          datanodeDetails.setPort(DatanodeDetails.newPort(HTTP, httpPort));
          serviceRuntimeInfo.setHttpPort(String.valueOf(httpPort));
        }

        if (policy.isHttpsEnabled()) {
          int httpsPort = httpServer.getHttpAddress().getPort();
          datanodeDetails.setPort(DatanodeDetails.newPort(HTTPS, httpsPort));
          serviceRuntimeInfo.setHttpsPort(String.valueOf(httpsPort));
        }

      } catch (Exception ex) {
        LOG.error("HttpServer failed to start.", ex);
      }

      clientProtocolServer = new HddsDatanodeClientProtocolServer(
          datanodeDetails, conf, HddsVersionInfo.HDDS_VERSION_INFO,
          reconfigurationHandler);

      int clientRpcport = clientProtocolServer.getClientRpcAddress().getPort();
      serviceRuntimeInfo.setClientRpcPort(String.valueOf(clientRpcport));

      // Get admin list
      String starterUser =
          UserGroupInformation.getCurrentUser().getShortUserName();
      admins = OzoneAdmins.getOzoneAdmins(starterUser, conf);
      LOG.info("Datanode start with admins: {}", admins.getAdminUsernames());

      clientProtocolServer.start();
      startPlugins();
      // Starting HDDS Daemons
      datanodeStateMachine.startDaemon();

      //for standalone, follower only test we can start the datanode (==raft
      // rings)
      //manually. In normal case it's handled by the initial SCM handshake.

      if ("follower"
          .equalsIgnoreCase(System.getenv("OZONE_DATANODE_STANDALONE_TEST"))) {
        startRatisForTest();
      }
      registerMXBean();
    } catch (IOException e) {
      throw new RuntimeException("Can't start the HDDS datanode plugin", e);
    } catch (AuthenticationException ex) {
      throw new RuntimeException("Fail to authentication when starting" +
          " HDDS datanode plugin", ex);
    }
  }