elasticsearch 启动步骤

发表于 | 分类于 | |

背景

ES的版本迭代较快每个版本启动和运行方式有所差异，本文以6.4.2版本说明。
6.4.2版本下载地址：https://www.elastic.co/downloads/elasticsearch

启动步骤

ES启动是通过下载包的 ./bin/elasticsearch叫本进行启动的。脚本定义了一些es和java的默认参数。可以通过修改脚本参数内容方式启动，控制台运行，比如修改esJVM大小等等。

Elasticsearch启动后 Elasticsearch类解析

Elasticsearch类启动时候运行main()函数，如下:

Elasticsearch初始化各种Option

Elasticsearch内部

解释：

  1. 运行System.setSecurityManager 配置默认管理器，默认使用的是 $JAVA_HOME/jre/lib/security/java.policy
  2. 注册Errorlistener,LogConfigurator.registerErrorListener();用于在失败的时候报错。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
/**
 * Main entry point for starting elasticsearch
 */
public static void main(final String[] args) throws Exception {
    // we want the JVM to think there is a security manager installed so that if internal policy decisions that would be based on the
    // presence of a security manager or lack thereof act as if there is a security manager present (e.g., DNS cache policy)
    System.setSecurityManager(new SecurityManager() {
        @Override
        public void checkPermission(Permission perm) {
            // grant all permissions so that we can later set the security manager to the one that we want
        }
    });
    LogConfigurator.registerErrorListener();
    final Elasticsearch elasticsearch = new Elasticsearch();
    int status = main(args, elasticsearch, Terminal.DEFAULT);
    if (status != ExitCodes.OK) {
        exit(status);
    }
}
  1. 启动Elasticsearch命令行客户端EnvironmentAwareCommand和对应用来输入Terminal

Elasticsearch

1
2
3
static int main(final String[] args, final Elasticsearch elasticsearch, final Terminal terminal) throws Exception {
    return elasticsearch.main(args, terminal);
}

EnvironmentAwareCommand

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

@Override
protected void execute(Terminal terminal, OptionSet options) throws Exception {
    final Map<String, String> settings = new HashMap<>();
    for (final KeyValuePair kvp : settingOption.values(options)) {
        if (kvp.value.isEmpty()) {
            throw new UserException(ExitCodes.USAGE, "setting [" + kvp.key + "] must not be empty");
        }
        if (settings.containsKey(kvp.key)) {
            final String message = String.format(
                    Locale.ROOT,
                    "setting [%s] already set, saw [%s] and [%s]",
                    kvp.key,
                    settings.get(kvp.key),
                    kvp.value);
            throw new UserException(ExitCodes.USAGE, message);
        }
        settings.put(kvp.key, kvp.value);
    }

    putSystemPropertyIfSettingIsMissing(settings, "path.data", "es.path.data");
    putSystemPropertyIfSettingIsMissing(settings, "path.home", "es.path.home");
    putSystemPropertyIfSettingIsMissing(settings, "path.logs", "es.path.logs");

    execute(terminal, options, createEnv(terminal, settings));
}

Elasticsearch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

Elasticsearch() {
    super("starts elasticsearch", () -> {}); // we configure logging later so we override the base class from configuring logging
    versionOption = parser.acceptsAll(Arrays.asList("V", "version"),
        "Prints elasticsearch version information and exits");
    daemonizeOption = parser.acceptsAll(Arrays.asList("d", "daemonize"),
        "Starts Elasticsearch in the background")
        .availableUnless(versionOption);
    pidfileOption = parser.acceptsAll(Arrays.asList("p", "pidfile"),
        "Creates a pid file in the specified path on start")
        .availableUnless(versionOption)
        .withRequiredArg()
        .withValuesConvertedBy(new PathConverter());
    quietOption = parser.acceptsAll(Arrays.asList("q", "quiet"),
        "Turns off standard output/error streams logging in console")
        .availableUnless(versionOption)
        .availableUnless(daemonizeOption);
}

  1. 创建Setting（HashMap)设置Elasticsearch配置

  2. 进行命令行相关的设置，初始化之后，跳转到Bootstrap中进行操作 init

Elasticsearch

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
@Override
protected void execute(Terminal terminal, OptionSet options, Environment env) throws UserException {
    if (options.nonOptionArguments().isEmpty() == false) {
        throw new UserException(ExitCodes.USAGE, "Positional arguments not allowed, found " + options.nonOptionArguments());
    }
    if (options.has(versionOption)) {
        final String versionOutput = String.format(
                Locale.ROOT,
                "Version: %s, Build: %s/%s/%s/%s, JVM: %s",
                Version.displayVersion(Version.CURRENT, Build.CURRENT.isSnapshot()),
                Build.CURRENT.flavor().displayName(),
                Build.CURRENT.type().displayName(),
                Build.CURRENT.shortHash(),
                Build.CURRENT.date(),
                JvmInfo.jvmInfo().version());
        terminal.println(versionOutput);
        return;
    }

    final boolean daemonize = options.has(daemonizeOption);
    final Path pidFile = pidfileOption.value(options);
    final boolean quiet = options.has(quietOption);

    // a misconfigured java.io.tmpdir can cause hard-to-diagnose problems later, so reject it immediately
    try {
        env.validateTmpFile();
    } catch (IOException e) {
        throw new UserException(ExitCodes.CONFIG, e.getMessage());
    }

    try {
        init(daemonize, pidFile, quiet, env);
    } catch (NodeValidationException e) {
        throw new UserException(ExitCodes.CONFIG, e.getMessage());
    }
}

void init(final boolean daemonize, final Path pidFile, final boolean quiet, Environment initialEnv)
    throws NodeValidationException, UserException {
    try {
        Bootstrap.init(!daemonize, pidFile, quiet, initialEnv);
    } catch (BootstrapException | RuntimeException e) {
        // format exceptions to the console in a special way
        // to avoid 2MB stacktraces from guice, etc.
        throw new StartupException(e);
    }
}

Bootstrap内部

  1. 初始化一个KeepAlive线程，内部的countDownLatch用于启动之后的心跳。保证节点运行期间Bootstrap一直存在。可以接受相关的命令退出
  2. 做了一些检查，SSL加密customConfFile
  3. 创建PID文件
  4. checkLucene版本
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
/**
   * This method is invoked by {@link Elasticsearch#main(String[])} to startup elasticsearch.
   */
  static void init(
          final boolean foreground,
          final Path pidFile,
          final boolean quiet,
          final Environment initialEnv) throws BootstrapException, NodeValidationException, UserException {
      // force the class initializer for BootstrapInfo to run before
      // the security manager is installed
      BootstrapInfo.init();

      INSTANCE = new Bootstrap();

      final SecureSettings keystore = loadSecureSettings(initialEnv);
      final Environment environment = createEnvironment(foreground, pidFile, keystore, initialEnv.settings(), initialEnv.configFile());
      try {
          LogConfigurator.configure(environment);
      } catch (IOException e) {
          throw new BootstrapException(e);
      }
      if (environment.pidFile() != null) {
          try {
              PidFile.create(environment.pidFile(), true);
          } catch (IOException e) {
              throw new BootstrapException(e);
          }
      }

      final boolean closeStandardStreams = (foreground == false) || quiet;
      try {
          if (closeStandardStreams) {
              final Logger rootLogger = ESLoggerFactory.getRootLogger();
              final Appender maybeConsoleAppender = Loggers.findAppender(rootLogger, ConsoleAppender.class);
              if (maybeConsoleAppender != null) {
                  Loggers.removeAppender(rootLogger, maybeConsoleAppender);
              }
              closeSystOut();
          }

          // fail if somebody replaced the lucene jars
          checkLucene();

          // install the default uncaught exception handler; must be done before security is
          // initialized as we do not want to grant the runtime permission
          // setDefaultUncaughtExceptionHandler
          Thread.setDefaultUncaughtExceptionHandler(
              new ElasticsearchUncaughtExceptionHandler(() -> Node.NODE_NAME_SETTING.get(environment.settings())));

          INSTANCE.setup(true, environment);

          try {
              // any secure settings must be read during node construction
              IOUtils.close(keystore);
          } catch (IOException e) {
              throw new BootstrapException(e);
          }

          INSTANCE.start();

          if (closeStandardStreams) {
              closeSysError();
          }
      } catch (NodeValidationException | RuntimeException e) {
          // disable console logging, so user does not see the exception twice (jvm will show it already)
          final Logger rootLogger = ESLoggerFactory.getRootLogger();
          final Appender maybeConsoleAppender = Loggers.findAppender(rootLogger, ConsoleAppender.class);
          if (foreground && maybeConsoleAppender != null) {
              Loggers.removeAppender(rootLogger, maybeConsoleAppender);
          }
          Logger logger = Loggers.getLogger(Bootstrap.class);
          if (INSTANCE.node != null) {
              logger = Loggers.getLogger(Bootstrap.class, Node.NODE_NAME_SETTING.get(INSTANCE.node.settings()));
          }
          // HACK, it sucks to do this, but we will run users out of disk space otherwise
          if (e instanceof CreationException) {
              // guice: log the shortened exc to the log file
              ByteArrayOutputStream os = new ByteArrayOutputStream();
              PrintStream ps = null;
              try {
                  ps = new PrintStream(os, false, "UTF-8");
              } catch (UnsupportedEncodingException uee) {
                  assert false;
                  e.addSuppressed(uee);
              }
              new StartupException(e).printStackTrace(ps);
              ps.flush();
              try {
                  logger.error("Guice Exception: {}", os.toString("UTF-8"));
              } catch (UnsupportedEncodingException uee) {
                  assert false;
                  e.addSuppressed(uee);
              }
          } else if (e instanceof NodeValidationException) {
              logger.error("node validation exception\n{}", e.getMessage());
          } else {
              // full exception
              logger.error("Exception", e);
          }
          // re-enable it if appropriate, so they can see any logging during the shutdown process
          if (foreground && maybeConsoleAppender != null) {
              Loggers.addAppender(rootLogger, maybeConsoleAppender);
          }

          throw e;
      }
  }

Node节点

  1. 根据Pid和是否守护进程等信息和之前是setting，创建运行时环境environment和pid文件。
  2. 检查所需的Lucene jar包
  3. 根据之前的environment,为每个plugin创建本地插件控制器：spawner
  4. 初始化本地资源（native方法进行一些OS调用和JVM信息，比如mlock/系统最大资源之类的）
  5. 初始化两种probes（探测），将提供给ES start时所需的一些进程信息和OS层面信息。
  6. 检查重复的jar包，并打印在日志中（JarHell.checkJarHell())

初始化Node节点（本地节点）

  1. 配置一个检查非回路的IP监测点
  2. 初始化nodeId和nodeName(new NodeEnvironment)
  3. 促使华ES各个功能模块的Service和module，并将service和module绑定

核心：真正启动Node和keeplive线程

node启动是在node中各个模块的胡同，通过guice获取各个module的service接口并启动
内部包括了master选举机制等。