Apache Bookkeeper的啟動流程解析

全局main函數(shù)實現(xiàn)

啟動代碼

位于bookkeeper-server/src/main/java/org/apache/bookkeeper/server/Main.java中

public static void main(String[] args) {
        int retCode = doMain(args);
        Runtime.getRuntime().exit(retCode);
    }

    static int doMain(String[] args) {
        ServerConfigurtion conf;
        // 0. parse command line
        try {
            conf = parseCommandLine(args);
        } catch (IllegalArgumentException iae) {
            return ExitCode.INVALID_CONF;
        }

        // 1. building the component stack:
        LifecycleComponent server;
        try {
            server = buildBookieServer(new BookieConfiguration(conf));
        } catch (Exception e) {
            log.error("Failed to build bookie server", e);
            return ExitCode.SERVER_EXCEPTION;
        }

        // 2. start the server
        try {
            ComponentStarter.startComponent(server).get();
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
            // the server is interrupted
            log.info("Bookie server is interrupted. Exiting ...");
        } catch (ExecutionException ee) {
            log.error("Error in bookie shutdown", ee.getCause());
            return ExitCode.SERVER_EXCEPTION;
        }
        return ExitCode.OK;
    }

啟動代碼很簡潔浊洞，且作了簡要注釋，主要啟動流程都封裝在了LifecycleComponent中;

配置解析

• 目前所有的配置項都可以通過配置文件來設(shè)置，這也是推薦的方式。因此大部分情況下啟動參數(shù)只需要傳一個配置文件的路徑即可;
• private static ServerConfiguration parseCommandLine(String[] args) 主要是從配置文件里加載各種配置懂诗，最后生成ServerConfiguration`對象，后續(xù)所有配置的讀取和修改都通過這個對象來操作;

服務(wù)構(gòu)建

• 每個bookie包括若干個子服務(wù)，每個子服務(wù)對應(yīng)一個Component, 需要一一啟動和關(guān)閉孵睬，這里使用LifecycleComponent來管理所有子服務(wù)的生命周期;
• 我們來看一下LifecycleComponet:

public class LifecycleComponentStack implements LifecycleComponent {
   public static Builder newBuilder() {
       return new Builder();
   }

   /**
    * Builder to build a stack of {@link LifecycleComponent}s.
    */
   public static class Builder {
       ...
       private final List<LifecycleComponent> components;

       private Builder() {
           components = Lists.newArrayList();
       }

       public Builder addComponent(LifecycleComponent component) {
           checkNotNull(component, "Lifecycle component is null");
           components.add(component);
           return this;
       }

       public LifecycleComponentStack build() {
           checkNotNull(name, "Lifecycle component stack name is not provided");
           checkArgument(!components.isEmpty(), "Lifecycle component stack is empty : " + components);
           return new LifecycleComponentStack(
               name,
               ImmutableList.copyOf(components));
       }
   }

   private final String name;
   private final ImmutableList<LifecycleComponent> components;

   private LifecycleComponentStack(String name,
                                   ImmutableList<LifecycleComponent> components) {
       this.name = name;
       this.components = components;
   }
   ....
   @Override
   public void start() {
       components.forEach(component -> component.start());
   }

   @Override
   public void stop() {
       components.reverse().forEach(component -> component.stop());
   }

   @Override
   public void close() {
       components.reverse().forEach(component -> component.close());
   }
}

1. 首先它內(nèi)置了Builder類，通過其addComponent方法將子組件加入進來伶跷，然后通過其build方法生成LifecycleComponent;
2. 從定義上來看LifecycleComponent也實現(xiàn)了LifecycleComponent,因此它也實現(xiàn)了start stop close, 只不過這些方 法操作的是其包含的合部Component;
3. 構(gòu)建啟動所需的所有子服務(wù)掰读，實現(xiàn)在buildBookieServer中

public static LifecycleComponentStack buildBookieServer(BookieConfiguration conf) throws Exception {
       LifecycleComponentStack.Builder serverBuilder = LifecycleComponentStack.newBuilder().withName("bookie-server");

       // 1. build stats provider
       serverBuilder.addComponent(statsProviderService);

       // 2. build bookie server
       serverBuilder.addComponent(bookieService);

       if (conf.getServerConf().isLocalScrubEnabled()) {
           serverBuilder.addComponent(
                   new ScrubberService(
                           rootStatsLogger.scope(ScrubberStats.SCOPE),
                   conf, bookieService.getServer().getBookie().getLedgerStorage()));
       }

       // 3. build auto recovery
           serverBuilder.addComponent(autoRecoveryService);
           log.info("Load lifecycle component : {}", AutoRecoveryService.class.getName());

       // 4. build http service
           serverBuilder.addComponent(httpService);

       // 5. build extra services
       ...
       
       return serverBuilder.build();
   }

這里需要啟動組件主要有：StatsProviderService, BookieService, ScrubberService, AutoRecoverryService和HttpService

服務(wù)啟動

• 組件啟動使用ComponentStarter來實現(xiàn)

public static CompletableFuture<Void> startComponent(LifecycleComponent component) {
        CompletableFuture<Void> future = new CompletableFuture<>();
        final Thread shutdownHookThread = new Thread(
            new ComponentShutdownHook(component, future),
            "component-shutdown-thread"
        );

        // register a shutdown hook
        Runtime.getRuntime().addShutdownHook(shutdownHookThread);

        // register a component exception handler
        component.setExceptionHandler((t, e) -> {
            // start the shutdown hook when an uncaught exception happen in the lifecycle component.
            shutdownHookThread.start();
        });

        component.start();
        return future;
    }

這個函數(shù)返回CompletableFuture<Void> future，當整個bookie結(jié)束或者拋出了未捕獲的異常時叭莫，這個future將被complete蹈集，對應(yīng)doMain中的代碼就是

    try {
            ComponentStarter.startComponent(server).get();
        } catch (InterruptedException ie) {
            Thread.currentThread().interrupt();
            // the server is interrupted
            log.info("Bookie server is interrupted. Exiting ...");
        } catch (ExecutionException ee) {
            log.error("Error in bookie shutdown", ee.getCause());
            return ExitCode.SERVER_EXCEPTION;
        }

其中ComponentStarter.startComponent(server).get()將阻塞等待future完成