flowchart TB
    subgraph "客户端层"
        HTTPClient[HTTP/REST 客户端]
        TCPClient[Transport 客户端]
    end

    subgraph "网关层 (REST Layer)"
        RestController[RestController<br/>路由控制器]
        RestHandler[RestHandler<br/>请求处理器]
        RestRequest[RestRequest<br/>请求封装]
    end

    subgraph "动作处理层 (Action Layer)"
        ActionModule[ActionModule<br/>动作模块]
        TransportAction[TransportAction<br/>传输动作]
        ActionRequest[ActionRequest<br/>请求对象]
    end

    subgraph "节点核心 (Node Core)"
        Node[Node<br/>节点实例]
        Injector[Guice Injector<br/>依赖注入]
        Lifecycle[Lifecycle<br/>生命周期管理]
        NodeClient[NodeClient<br/>节点客户端]
    end

    subgraph "核心业务层 (Business Layer)"
        IS[IndicesService<br/>索引服务]
        SS[SearchService<br/>搜索服务]
        CS[ClusterService<br/>集群服务]
        ICSS[IndicesClusterStateService<br/>索引集群状态服务]
    end

    subgraph "传输层 (Transport Layer)"
        TS[TransportService<br/>传输服务]
        TCP[TcpTransport<br/>TCP传输]
        Netty[Netty<br/>网络框架]
    end

    subgraph "存储层 (Storage Layer)"
        Shard[IndexShard<br/>索引分片]
        Engine[InternalEngine<br/>存储引擎]
        Lucene[Lucene<br/>搜索库]
        Translog[Translog<br/>事务日志]
    end

    subgraph "支持组件层 (Infrastructure)"
        TP[ThreadPool<br/>线程池]
        Monitor[MonitorService<br/>监控服务]
        Gateway[GatewayService<br/>网关持久化]
        Plugins[PluginsService<br/>插件服务]
    end

    HTTPClient --> RestController
    TCPClient --> TS

    RestController --> RestHandler
    RestHandler --> RestRequest
    RestRequest --> ActionModule

    ActionModule --> TransportAction
    TransportAction --> ActionRequest
    ActionRequest --> NodeClient

    NodeClient --> Injector
    Injector --> IS
    Injector --> SS
    Injector --> CS

    IS --> Shard
    SS --> Shard
    Shard --> Engine
    Engine --> Lucene
    Engine --> Translog

    TransportAction --> TS
    TS --> TCP
    TCP --> Netty

    IS --> TP
    SS --> TP
    CS --> Gateway
    Node --> Plugins

    style HTTPClient fill:#e1f5ff
    style RestController fill:#fff4e1
    style ActionModule fill:#f5e1ff
    style Node fill:#ffe1f5
    style IS fill:#e1ffe1
    style TS fill:#f5f5e1
    style Engine fill:#ffe1e1
    style TP fill:#e1e1f5

flowchart LR
    Client[客户端] --> REST[REST Layer]
    REST --> Action[Action Layer]
    Action --> Business[Business Layer]
    Business --> Storage[Storage Layer]
    Storage --> Lucene[Lucene]

flowchart LR
    Cluster[ClusterService] -->|发布状态| Transport[TransportService]
    Transport -->|广播| Nodes[所有节点]
    Nodes -->|应用状态| ICSS[IndicesClusterStateService]

flowchart TB
    ClusterService[ClusterService] -->|状态变更事件| Listeners[ClusterStateListener]
    Listeners --> ICSS[IndicesClusterStateService]
    Listeners --> SearchService[SearchService]
    Listeners --> Plugins[Plugin Listeners]

Client → REST API → IndexAction → TransportIndexAction
  → IndexShard → InternalEngine → Lucene IndexWriter
  → Translog → Disk

Client → REST API → SearchAction → TransportSearchAction
  → SearchService → IndexShard → InternalEngine
  → Lucene IndexSearcher → 返回结果

Master Node → ClusterService → PublishClusterState
  → TransportService → All Nodes → ApplyClusterState
  → IndicesClusterStateService → 创建/删除分片

flowchart TB
    Start[启动 main 方法] --> Phase1[Phase 1:<br/>基础初始化]

    Phase1 --> P1_1[初始化安全属性]
    P1_1 --> P1_2[读取启动参数]
    P1_2 --> P1_3[初始化环境]
    P1_3 --> P1_4[配置日志系统]

    P1_4 --> Phase2[Phase 2:<br/>安全管理器初始化]

    Phase2 --> P2_1[创建环境对象]
    P2_1 --> P2_2[写入 PID 文件]
    P2_2 --> P2_3[初始化本地库<br/>JNA/JNI]
    P2_3 --> P2_4[检查 Jar Hell]
    P2_4 --> P2_5[配置安全管理器]
    P2_5 --> P2_6[加载插件]

    P2_6 --> Phase3[Phase 3:<br/>节点构建与启动]

    Phase3 --> P3_1[创建 Node 对象]
    P3_1 --> P3_2[构建依赖注入容器]
    P3_2 --> P3_3[注册所有服务]
    P3_3 --> P3_4[启动所有服务]
    P3_4 --> P3_5[执行 Bootstrap 检查]
    P3_5 --> P3_6[通知 CLI 准备就绪]

    P3_6 --> Running[节点运行中]

private static Bootstrap initPhase1() {
    // 1. 初始化安全属性
    initSecurityProperties();

    // 2. 初始化 BootstrapInfo
    BootstrapInfo.init();

    // 3. 读取启动参数
    ServerArgs args = new ServerArgs(System.in);

    // 4. 创建环境对象（仅路径信息）
    Environment nodeEnv = new Environment(args.nodeSettings(), args.configDir());

    // 5. 配置日志系统（必须在最后）
    LogConfigurator.configure(nodeEnv, args.quiet() == false);

    return new Bootstrap(args);
}

private static void initPhase2(Bootstrap bootstrap) {
    // 1. 创建完整的环境对象（包含 SecureSettings）
    Environment nodeEnv = createEnvironment(args.configDir(), args.nodeSettings(), secrets);

    // 2. 写入 PID 文件
    initPidFile(args.pidFile());

    // 3. 设置全局异常处理器
    Thread.setDefaultUncaughtExceptionHandler(new ElasticsearchUncaughtExceptionHandler());

    // 4. 初始化本地库（JNA/JNI）
    initializeNatives(
        nodeEnv.tmpDir(),
        MEMORY_LOCK_SETTING.get(args.nodeSettings()),
        true,  // 系统调用过滤器
        CTRLHANDLER_SETTING.get(args.nodeSettings())
    );

    // 5. 检查 Jar Hell（类路径冲突）
    JarHell.checkJarHell();

    // 6. 加载插件
    PluginsLoader pluginsLoader = PluginsLoader.createPluginsLoader(nodeEnv);

    // 7. 配置安全管理器（可选）
    if (enableSecurityManager) {
        Security.setSecurityManager(new SecurityManager());
    }
}

private static void initPhase3(Bootstrap bootstrap) {
    // 1. 创建 Node 对象
    Node node = new Node(bootstrap.environment(), bootstrap.pluginsLoader());

    // 2. 启动节点
    node.start();

    // 3. 通知 CLI 进程准备就绪
    bootstrap.sendCliMarker(BootstrapInfo.SERVER_READY_MARKER);
}

public Node(Environment environment, PluginsLoader pluginsLoader) {
    // 1. 创建依赖注入容器（Guice）
    Injector injector = createInjector(environment, pluginsLoader);

    // 2. 注册所有核心服务
    registerServices(injector);
}

public Node start() {
    // 1. 更新生命周期状态
    lifecycle.moveToStarted();

    // 2. 启动插件生命周期组件
    pluginLifecycleComponents.forEach(LifecycleComponent::start);

    // 3. 启动核心服务（按依赖顺序）
    injector.getInstance(IndicesService.class).start();
    injector.getInstance(IndicesClusterStateService.class).start();
    injector.getInstance(SnapshotsService.class).start();
    injector.getInstance(SearchService.class).start();
    injector.getInstance(ClusterService.class).start();
    injector.getInstance(TransportService.class).start();
    injector.getInstance(Coordinator.class).start();
    injector.getInstance(GatewayService.class).start();

    // 4. 启动 HTTP 服务器
    injector.getInstance(HttpServerTransport.class).start();

    // 5. 执行启动前验证
    validateNodeBeforeAcceptingRequests();

    return this;
}

stateDiagram-v2
    [*] --> Initialized: 构造 Node
    Initialized --> Starting: start()
    Starting --> Started: 启动完成
    Started --> Stopping: stop()
    Stopping --> Stopped: 停止完成
    Stopped --> Closing: close()
    Closing --> Closed: 关闭完成
    Closed --> [*]

    Started --> Closing: 异常/强制关闭

flowchart LR
    TP[ThreadPool] --> IS[IndicesService]
    IS --> ICSS[IndicesClusterStateService]
    ICSS --> SS[SnapshotsService]
    SS --> Search[SearchService]
    Search --> CS[ClusterService]
    CS --> TS[TransportService]
    TS --> Coord[Coordinator]
    Coord --> GW[GatewayService]
    GW --> HTTP[HttpServerTransport]

classDiagram
    class Node {
        -Lifecycle lifecycle
        -Injector injector
        -Environment environment
        -NodeEnvironment nodeEnvironment
        -PluginsService pluginsService
        -NodeClient client
        -Collection~LifecycleComponent~ pluginLifecycleComponents
        +Node(Environment, PluginsLoader)
        +start() Node
        +close()
    }

    class Lifecycle {
        -State state
        +moveToStarted() boolean
        +moveToStopped() boolean
        +moveToClosed() boolean
        +state() State
    }

    class State {
        <<enumeration>>
        INITIALIZED
        STARTING
        STARTED
        STOPPING
        STOPPED
        CLOSING
        CLOSED
    }

    class Environment {
        -Settings settings
        -Path configDir
        -Path[] dataFiles
        -Path logsDir
        -Path tmpDir
        +settings() Settings
        +configDir() Path
        +dataFiles() Path[]
    }

    Node --> Lifecycle
    Node --> Environment
    Lifecycle --> State

classDiagram
    class LifecycleComponent {
        <<interface>>
        +start()
        +stop()
        +close()
        +lifecycleState() State
    }

    class AbstractLifecycleComponent {
        <<abstract>>
        #Lifecycle lifecycle
        +start()
        +stop()
        +close()
        #doStart()
        #doStop()
        #doClose()
    }

    class TransportService {
        +start()
        +stop()
        +close()
    }

    class ClusterService {
        +start()
        +stop()
        +close()
    }

    class IndicesService {
        +start()
        +stop()
        +close()
    }

    LifecycleComponent <|.. AbstractLifecycleComponent
    AbstractLifecycleComponent <|-- TransportService
    AbstractLifecycleComponent <|-- ClusterService
    AbstractLifecycleComponent <|-- IndicesService

classDiagram
    class Injector {
        <<Guice>>
        +getInstance(Class~T~) T
        +getInstance(Key~T~) T
    }

    class NodeModule {
        <<abstract>>
        +configure()
        #bindService(Class, Class)
    }

    class ClusterModule {
        +configure()
    }

    class TransportModule {
        +configure()
    }

    class IndicesModule {
        +configure()
    }

    Injector ..> NodeModule
    NodeModule <|-- ClusterModule
    NodeModule <|-- TransportModule
    NodeModule <|-- IndicesModule

classDiagram
    class PluginsService {
        -List~PluginInfo~ pluginsInfo
        -List~Plugin~ plugins
        -Map~Class, List~ pluginMap
        +PluginsService(Settings, Path, Path, Path)
        +getPluginInfos() List~PluginInfo~
        +filterPlugins(Class~T~) List~T~
    }

    class Plugin {
        <<interface>>
        +createComponents(...) Collection~Object~
        +getActions() List~ActionHandler~
        +getRestHandlers(...) List~RestHandler~
        +getSettings() List~Setting~
    }

    class PluginInfo {
        -String name
        -String description
        -String version
        -String classname
        +getName() String
        +getVersion() String
    }

    class PluginBundle {
        -PluginDescriptor pluginDescriptor
        -ClassLoader classLoader
        -Set~URL~ urls
    }

    PluginsService --> Plugin
    PluginsService --> PluginInfo
    PluginsService --> PluginBundle

classDiagram
    class NodeEnvironment {
        -Settings settings
        -Path[] nodePaths
        -Lock[] locks
        -NodeId nodeId
        +NodeEnvironment(Settings, Environment)
        +nodeDataPaths() Path[]
        +nodeId() NodeId
        +close()
    }

    class NodeId {
        -String id
        +NodeId(String)
        +getId() String
    }

    class NodePath {
        -Path path
        -long totalSpace
        -long freeSpace
        +getPath() Path
        +getTotalSpace() long
    }

    NodeEnvironment --> NodeId
    NodeEnvironment --> NodePath

classDiagram
    class ThreadPool {
        -Map~String, ExecutorHolder~ executors
        -ScheduledThreadPoolExecutor scheduler
        +ThreadPool(Settings)
        +generic() ExecutorService
        +executor(String) ExecutorService
        +schedule(Runnable, TimeValue, String) ScheduledFuture
        +shutdown()
    }

    class ExecutorHolder {
        -ExecutorService executor
        -ThreadPoolInfo info
        +executor() ExecutorService
        +info() ThreadPoolInfo
    }

    class ThreadPoolInfo {
        -String name
        -String type
        -int size
        -int queueSize
        +getName() String
        +getType() String
    }

    ThreadPool --> ExecutorHolder
    ExecutorHolder --> ThreadPoolInfo

classDiagram
    class Settings {
        -Map~String, String~ settings
        +get(String) String
        +getAsInt(String, int) int
        +getAsBoolean(String, boolean) boolean
        +builder() Builder
    }

    class Builder {
        -Map~String, String~ map
        +put(String, String) Builder
        +put(String, int) Builder
        +build() Settings
    }

    class Setting {
        <<abstract>>
        -String key
        -Function parser
        -T defaultValue
        +get(Settings) T
        +exists(Settings) boolean
    }

    Settings --> Builder
    Settings ..> Setting

public static final Setting<Integer> HTTP_PORT =
    Setting.intSetting("http.port", 9200, 1024, 65535, Property.NodeScope);

// 使用
int port = HTTP_PORT.get(settings);

public Node(Environment environment, PluginsLoader pluginsLoader)

public Node(Environment environment, PluginsLoader pluginsLoader) {
    // 1. 准备构造上下文
    NodeConstruction construction = NodeConstruction.prepareConstruction(
        environment,
        pluginsLoader,
        new NodeServiceProvider(),
        true
    );

    // 2. 创建依赖注入容器
    this.injector = construction.injector();

    // 3. 获取核心组件
    this.environment = injector.getInstance(Environment.class);
    this.nodeEnvironment = injector.getInstance(NodeEnvironment.class);
    this.pluginsService = injector.getInstance(PluginsService.class);
    this.client = injector.getInstance(NodeClient.class);

    // 4. 收集插件生命周期组件
    this.pluginLifecycleComponents = construction.pluginLifecycleComponents();
}

public Node start() throws NodeValidationException

public Node start() throws NodeValidationException {
    // 1. 状态检查
    if (lifecycle.moveToStarted() == false) {
        return this;  // 已经启动
    }

    // 2. 启动插件组件
    pluginLifecycleComponents.forEach(LifecycleComponent::start);

    // 3. 启动核心服务（按依赖顺序）
    injector.getInstance(IndicesService.class).start();
    injector.getInstance(IndicesClusterStateService.class).start();
    injector.getInstance(SnapshotsService.class).start();
    injector.getInstance(SearchService.class).start();
    injector.getInstance(FsHealthService.class).start();
    injector.getInstance(MonitorService.class).start();

    // 4. 启动集群服务
    ClusterService clusterService = injector.getInstance(ClusterService.class);
    NodeConnectionsService nodeConnectionsService = injector.getInstance(NodeConnectionsService.class);
    nodeConnectionsService.start();
    clusterService.setNodeConnectionsService(nodeConnectionsService);

    // 5. 启动协调器
    Coordinator coordinator = injector.getInstance(Coordinator.class);
    clusterService.getMasterService().setClusterStatePublisher(coordinator);

    // 6. 启动传输服务
    TransportService transportService = injector.getInstance(TransportService.class);
    transportService.start();
    transportService.acceptIncomingRequests();

    // 7. 启动网关服务
    injector.getInstance(GatewayService.class).start();

    // 8. 启动 HTTP 服务器
    injector.getInstance(HttpServerTransport.class).start();

    // 9. 执行启动前验证
    validateNodeBeforeAcceptingRequests();

    return this;
}

private void stop()

private void stop() {
    // 1. 状态检查
    if (lifecycle.moveToStopped() == false) {
        return;
    }

    // 2. 停止 HTTP 服务器（停止接收新请求）
    stopIfStarted(HttpServerTransport.class);

    // 3. 停止快照和仓库服务
    stopIfStarted(SnapshotsService.class);
    stopIfStarted(SnapshotShardsService.class);
    stopIfStarted(RepositoriesService.class);

    // 4. 停止索引集群状态服务
    stopIfStarted(IndicesClusterStateService.class);

    // 5. 停止协调器（停止响应集群状态更新）
    stopIfStarted(Coordinator.class);

    // 6. 停止集群服务
    stopIfStarted(ClusterService.class);
    stopIfStarted(NodeConnectionsService.class);

    // 7. 停止其他服务
    stopIfStarted(FsHealthService.class);
    stopIfStarted(MonitorService.class);
    stopIfStarted(GatewayService.class);
    stopIfStarted(SearchService.class);
    stopIfStarted(TransportService.class);

    // 8. 停止插件组件
    pluginLifecycleComponents.forEach(Node::stopIfStarted);

    // 9. 最后停止索引服务（等待资源释放）
    stopIfStarted(IndicesService.class);
}

@Override
public synchronized void close() throws IOException

@Override
public synchronized void close() throws IOException {
    synchronized (lifecycle) {
        // 1. 如果还在运行，先停止
        if (lifecycle.started()) {
            stop();
        }

        // 2. 状态检查
        if (lifecycle.moveToClosed() == false) {
            return;
        }
    }

    // 3. 关闭所有组件（逆启动顺序）
    List<Closeable> toClose = new ArrayList<>();

    toClose.add(injector.getInstance(HttpServerTransport.class));
    toClose.add(injector.getInstance(SnapshotsService.class));
    toClose.add(injector.getInstance(IndicesClusterStateService.class));
    toClose.add(injector.getInstance(IndicesService.class));
    toClose.add(injector.getInstance(IndicesStore.class));
    toClose.add(injector.getInstance(ClusterService.class));
    toClose.add(injector.getInstance(NodeConnectionsService.class));
    toClose.add(injector.getInstance(Coordinator.class));
    toClose.add(injector.getInstance(MonitorService.class));
    toClose.add(injector.getInstance(GatewayService.class));
    toClose.add(injector.getInstance(SearchService.class));
    toClose.add(injector.getInstance(TransportService.class));

    // 4. 关闭插件
    pluginLifecycleComponents.forEach(toClose::add);
    pluginsService.filterPlugins(Plugin.class).forEach(toClose::add);

    // 5. 关闭线程池
    toClose.add(() -> injector.getInstance(ThreadPool.class).shutdown());

    // 6. 关闭节点环境
    toClose.add(injector.getInstance(NodeEnvironment.class));

    // 7. 批量关闭
    IOUtils.close(toClose);
}

public interface LifecycleComponent extends Closeable {
    void start();
    void stop();
    void close() throws IOException;
    Lifecycle.State lifecycleState();
}

public class Lifecycle {
    private volatile State state = State.INITIALIZED;

    public boolean moveToStarted() {
        State localState = state;
        if (localState == State.INITIALIZED || localState == State.STOPPED) {
            state = State.STARTED;
            return true;
        }
        return false;
    }

    public boolean moveToStopped() {
        State localState = state;
        if (localState == State.STARTED) {
            state = State.STOPPED;
            return true;
        }
        return false;
    }

    public boolean moveToClosed() {
        State localState = state;
        if (localState == State.CLOSED) {
            return false;
        }
        state = State.CLOSED;
        return true;
    }
}

public Environment(Settings settings, Path configPath)

public class Environment {
    // 获取配置目录
    public Path configDir();

    // 获取数据目录
    public Path[] dataFiles();

    // 获取日志目录
    public Path logsDir();

    // 获取临时目录
    public Path tmpDir();

    // 获取节点设置
    public Settings settings();
}

public class NodeClient extends AbstractClient {
    // 执行 Action
    @Override
    public <Request extends ActionRequest, Response extends ActionResponse>
    void doExecute(ActionType<Response> action, Request request, ActionListener<Response> listener) {
        // 查找 TransportAction
        TransportAction<Request, Response> transportAction = actions.get(action);

        // 执行操作
        transportAction.execute(null, request, listener);
    }
}

public class PluginsService {
    public PluginsService(
        Settings settings,
        Path configPath,
        Path modulesPath,
        Path pluginsPath
    ) {
        // 1. 加载模块（内置插件）
        List<PluginBundle> moduleBundles = loadBundles(modulesPath);

        // 2. 加载插件
        List<PluginBundle> pluginBundles = loadBundles(pluginsPath);

        // 3. 初始化所有插件
        this.plugins = new ArrayList<>();
        for (PluginBundle bundle : allBundles) {
            Plugin plugin = loadPlugin(bundle);
            plugins.add(plugin);
        }
    }
}

public interface Plugin {
    // 创建自定义组件
    default Collection<Object> createComponents(...) {
        return Collections.emptyList();
    }

    // 注册 Action
    default List<ActionHandler<? extends ActionRequest, ? extends ActionResponse>> getActions() {
        return Collections.emptyList();
    }

    // 注册 REST Handler
    default List<RestHandler> getRestHandlers(...) {
        return Collections.emptyList();
    }

    // 自定义设置
    default List<Setting<?>> getSettings() {
        return Collections.emptyList();
    }
}

public abstract class BootstrapCheck {
    public abstract BootstrapCheckResult check(BootstrapContext context);
}

sequenceDiagram
    autonumber
    participant Main as main 方法
    participant ES as Elasticsearch
    participant Bootstrap as Bootstrap
    participant Node as Node
    participant Injector as Guice Injector
    participant Services as Core Services

    Note over Main,Services: Phase 1: 基础初始化

    Main->>ES: main(args)
    ES->>ES: initPhase1()
    ES->>ES: initSecurityProperties()
    ES->>ES: BootstrapInfo.init()
    ES->>ES: 读取 ServerArgs
    ES->>ES: 创建 Environment
    ES->>ES: 配置日志系统
    ES->>Bootstrap: new Bootstrap(args)
    Bootstrap-->>ES: bootstrap

    Note over Main,Services: Phase 2: 安全管理器初始化

    ES->>Bootstrap: initPhase2(bootstrap)
    Bootstrap->>Bootstrap: 创建完整 Environment
    Bootstrap->>Bootstrap: 写入 PID 文件
    Bootstrap->>Bootstrap: 设置异常处理器
    Bootstrap->>Bootstrap: 初始化本地库 (JNA)
    Bootstrap->>Bootstrap: 检查 Jar Hell
    Bootstrap->>Bootstrap: 加载插件
    Bootstrap->>Bootstrap: 配置安全管理器

    Note over Main,Services: Phase 3: 节点构建与启动

    ES->>Bootstrap: initPhase3(bootstrap)
    Bootstrap->>Node: new Node(environment, pluginsLoader)

    Node->>Node: prepareConstruction()
    Node->>Injector: 创建 Guice Injector
    Injector->>Injector: 注册所有 Module
    Injector->>Injector: 创建所有服务实例
    Injector-->>Node: injector

    Node->>Node: 获取核心组件引用
    Node-->>Bootstrap: node

    Bootstrap->>Node: start()

    Node->>Node: lifecycle.moveToStarted()

    loop 启动所有服务
        Node->>Services: start()
        Services->>Services: 初始化资源
        Services-->>Node: started
    end

    Node->>Node: validateNodeBeforeAcceptingRequests()
    Node-->>Bootstrap: started

    Bootstrap->>Bootstrap: sendCliMarker(SERVER_READY)
    Bootstrap-->>Main: 节点准备就绪

sequenceDiagram
    autonumber
    participant Node
    participant Plugins as Plugin Components
    participant IS as IndicesService
    participant ICSS as IndicesClusterStateService
    participant Snapshots as SnapshotsService
    participant Search as SearchService
    participant CS as ClusterService
    participant TS as TransportService
    participant Coord as Coordinator
    participant GW as GatewayService
    participant HTTP as HttpServerTransport

    Node->>Node: lifecycle.moveToStarted()

    Note over Node,HTTP: 步骤1: 启动插件组件

    Node->>Plugins: forEach(start)
    Plugins->>Plugins: 初始化插件资源
    Plugins-->>Node: started

    Note over Node,HTTP: 步骤2: 启动索引服务

    Node->>IS: start()
    IS->>IS: 启动索引管理器
    IS-->>Node: started

    Node->>ICSS: start()
    ICSS->>ICSS: 启动集群状态监听
    ICSS-->>Node: started

    Note over Node,HTTP: 步骤3: 启动快照服务

    Node->>Snapshots: start()
    Snapshots->>Snapshots: 初始化快照管理
    Snapshots-->>Node: started

    Note over Node,HTTP: 步骤4: 启动搜索服务

    Node->>Search: start()
    Search->>Search: 初始化搜索线程池
    Search-->>Node: started

    Note over Node,HTTP: 步骤5: 启动集群服务

    Node->>CS: start()
    CS->>CS: 启动 MasterService
    CS->>CS: 启动 ClusterApplierService
    CS-->>Node: started

    Note over Node,HTTP: 步骤6: 启动传输服务

    Node->>TS: start()
    TS->>TS: 绑定传输地址
    TS->>TS: 启动 Netty Server
    TS->>TS: acceptIncomingRequests()
    TS-->>Node: started

    Note over Node,HTTP: 步骤7: 启动协调器

    Node->>Coord: start()
    Coord->>Coord: 启动主节点选举
    Coord->>Coord: 加入集群
    Coord-->>Node: started

    Note over Node,HTTP: 步骤8: 启动网关服务

    Node->>GW: start()
    GW->>GW: 恢复集群状态
    GW-->>Node: started

    Note over Node,HTTP: 步骤9: 启动 HTTP 服务

    Node->>HTTP: start()
    HTTP->>HTTP: 绑定 HTTP 地址
    HTTP->>HTTP: 启动 Netty HTTP Server
    HTTP-->>Node: started

    Node->>Node: validateNodeBeforeAcceptingRequests()

sequenceDiagram
    autonumber
    participant Node
    participant HTTP as HttpServerTransport
    participant Coord as Coordinator
    participant CS as ClusterService
    participant TS as TransportService
    participant IS as IndicesService
    participant TP as ThreadPool
    participant NE as NodeEnvironment

    Node->>Node: close()

    Note over Node,NE: 步骤1: 先停止再关闭

    alt 节点还在运行
        Node->>Node: stop()
    end

    Node->>Node: lifecycle.moveToClosed()

    Note over Node,NE: 步骤2: 关闭 HTTP (停止接收新请求)

    Node->>HTTP: close()
    HTTP->>HTTP: unbind()
    HTTP->>HTTP: 关闭所有连接
    HTTP-->>Node: closed

    Note over Node,NE: 步骤3: 关闭协调器

    Node->>Coord: close()
    Coord->>Coord: 停止主节点选举
    Coord->>Coord: 离开集群
    Coord-->>Node: closed

    Note over Node,NE: 步骤4: 关闭集群服务

    Node->>CS: close()
    CS->>CS: 停止状态更新
    CS-->>Node: closed

    Note over Node,NE: 步骤5: 关闭传输服务

    Node->>TS: close()
    TS->>TS: 关闭所有连接
    TS->>TS: 停止 Netty
    TS-->>Node: closed

    Note over Node,NE: 步骤6: 关闭索引服务

    Node->>IS: close()
    IS->>IS: 关闭所有索引
    IS->>IS: 刷新数据到磁盘
    IS-->>Node: closed

    Note over Node,NE: 步骤7: 关闭线程池

    Node->>TP: shutdown()
    TP->>TP: 停止所有线程
    TP->>TP: 等待任务完成
    TP-->>Node: shutdown

    Note over Node,NE: 步骤8: 关闭节点环境

    Node->>NE: close()
    NE->>NE: 释放文件锁
    NE-->>Node: closed

sequenceDiagram
    autonumber
    participant Bootstrap
    participant PL as PluginsLoader
    participant PS as PluginsService
    participant Plugin
    participant Injector as Guice Injector

    Bootstrap->>PL: createPluginsLoader(env)

    PL->>PL: 扫描 plugins 目录
    PL->>PL: 扫描 modules 目录

    loop 每个插件/模块
        PL->>PL: 读取 plugin-descriptor.properties
        PL->>PL: 创建 ClassLoader
        PL->>PL: 创建 PluginBundle
    end

    PL-->>Bootstrap: pluginsLoader

    Bootstrap->>PS: new PluginsService(settings, pluginsLoader)

    loop 每个 PluginBundle
        PS->>PS: 加载插件类
        PS->>Plugin: 实例化插件
        Plugin-->>PS: plugin instance
        PS->>PS: 收集扩展点
    end

    PS-->>Bootstrap: pluginsService

    Note over Bootstrap,Injector: 构建依赖注入容器

    Bootstrap->>Injector: createInjector(...)

    loop 每个插件
        Injector->>Plugin: createComponents(...)
        Plugin-->>Injector: custom components

        Injector->>Plugin: getActions()
        Plugin-->>Injector: action handlers

        Injector->>Plugin: getRestHandlers(...)
        Plugin-->>Injector: REST handlers
    end

    Injector-->>Bootstrap: injector with plugins

sequenceDiagram
    autonumber
    participant Client as HTTP Client
    participant Netty as Netty HTTP Server
    participant RC as RestController
    participant RH as RestIndexAction<br/>(RestHandler)
    participant AM as ActionModule
    participant TA as TransportIndexAction
    participant Primary as Primary Shard Node
    participant IS as IndicesService
    participant Shard as IndexShard
    participant Engine as InternalEngine
    participant Lucene as Lucene
    participant TL as Translog
    participant Replica as Replica Shards

    Note over Client,Replica: 步骤1: HTTP请求接收与路由

    Client->>Netty: POST /my-index/_doc/1<br/>{\"field\":\"value\"}
    Netty->>Netty: 解析HTTP请求
    Netty->>RC: dispatchRequest(httpRequest)

    RC->>RC: 路由匹配<br/>POST /{index}/_doc/{id}
    RC->>RH: handleRequest(request, channel)

    Note over Client,Replica: 步骤2: REST层处理与参数解析

    RH->>RH: 解析路径参数<br/>(index, id)
    RH->>RH: 解析查询参数<br/>(refresh, timeout, routing)
    RH->>RH: 解析请求体<br/>(JSON document)

    RH->>RH: 构造IndexRequest
    RH->>AM: prepareIndex(IndexRequest)

    Note over Client,Replica: 步骤3: Action层处理

    AM->>TA: execute(IndexRequest, ActionListener)

    TA->>TA: 解析路由信息<br/>routing = id (默认)
    TA->>TA: 计算分片<br/>shardId = hash(routing) % num_shards

    TA->>TA: 获取集群状态<br/>查找Primary Shard位置

    alt 本地节点是Primary
        TA->>Primary: 本地调用
    else 远程节点是Primary
        TA->>Primary: TransportService.sendRequest()
    end

    Note over Client,Replica: 步骤4: Primary Shard处理

    Primary->>IS: index(IndexRequest)
    IS->>Shard: index(IndexRequest)

    Shard->>Shard: 前置检查<br/>(分片状态, 版本)
    Shard->>Shard: 分配 SequenceNumber
    Shard->>Shard: 分配 primaryTerm

    Note over Client,Replica: 步骤5: Engine层处理

    Shard->>Engine: index(Index operation)

    Engine->>Engine: 获取UID锁<br/>versionMap.acquireLock(uid)
    Engine->>Engine: 版本冲突检测<br/>checkVersionConflict()

    alt 版本冲突
        Engine-->>Shard: VersionConflictException
        Shard-->>TA: 409 Conflict
        TA-->>Client: 409 Conflict
    end

    Note over Client,Replica: 步骤6: 写入Lucene和Translog

    alt 新文档
        Engine->>Lucene: addDocument(doc)
    else 更新文档
        Engine->>Lucene: updateDocument(term, doc)
    end

    Lucene->>Lucene: 写入内存缓冲<br/>(IndexWriter buffer)
    Lucene-->>Engine: success

    Engine->>TL: add(IndexOperation)
    TL->>TL: 序列化操作
    TL->>TL: 追加到当前generation

    alt translog.durability = REQUEST
        TL->>TL: fsync() 立即刷盘
    else translog.durability = ASYNC
        TL->>TL: 异步刷盘(5秒)
    end

    TL-->>Engine: Location

    Engine->>Engine: 更新LiveVersionMap<br/>记录版本和Location
    Engine->>Engine: 释放UID锁

    Engine-->>Shard: IndexResult

    Note over Client,Replica: 步骤7: 副本复制

    par 并行复制到所有副本
        Shard->>Replica: ReplicationRequest<br/>(doc, seqNo, primaryTerm)
        Replica->>Replica: 应用操作<br/>(使用相同seqNo)
        Replica->>Replica: 写入Engine
        Replica->>Replica: 写入Translog
        Replica-->>Shard: ACK
    end

    Shard->>Shard: 等待所有副本确认<br/>(或部分确认)

    Note over Client,Replica: 步骤8: 返回响应

    Shard-->>IS: IndexResult
    IS-->>Primary: IndexResult
    Primary-->>TA: IndexResponse

    TA->>TA: 构造HTTP响应
    TA->>RC: IndexResponse
    RC->>Netty: HTTP 201 Created
    Netty-->>Client: {"_id":"1","_version":1,"result":"created"}

// Netty4HttpServerTransport
public class Netty4HttpServerTransport extends AbstractHttpServerTransport {
    protected void dispatchRequest(HttpRequest request, HttpChannel channel) {
        // 解析HTTP方法和路径
        RestRequest restRequest = new RestRequest(request, channel);

        // 交给RestController处理
        restController.dispatchRequest(restRequest, channel, threadContext);
    }
}

public class RestController implements HttpServerTransport.Dispatcher {
    public void dispatchRequest(RestRequest request, RestChannel channel, ThreadContext threadContext) {
        // 1. 查找匹配的Handler
        RestHandler handler = handlerMap.get(request.method(), request.path());

        // 2. 执行Handler
        handler.handleRequest(request, channel, client);
    }
}

public class RestIndexAction extends BaseRestHandler {
    @Override
    public RestChannelConsumer prepareRequest(RestRequest request, NodeClient client) {
        // 1. 解析路径参数
        String index = request.param("index");
        String id = request.param("id");

        // 2. 解析查询参数
        String routing = request.param("routing");
        boolean refresh = request.paramAsBoolean("refresh", false);
        TimeValue timeout = request.paramAsTime("timeout", TimeValue.timeValueSeconds(60));

        // 3. 解析请求体
        BytesReference source = request.requiredContent();

        // 4. 构造IndexRequest
        IndexRequest indexRequest = new IndexRequest(index);
        indexRequest.id(id);
        indexRequest.routing(routing);
        indexRequest.source(source, request.getXContentType());
        indexRequest.timeout(timeout);

        // 5. 执行请求
        return channel -> client.index(indexRequest, new RestToXContentListener<>(channel));
    }
}

public class TransportIndexAction extends TransportReplicationAction<IndexRequest, IndexRequest, IndexResponse> {
    @Override
    protected void doExecute(Task task, IndexRequest request, ActionListener<IndexResponse> listener) {
        // 1. 解析路由键
        String routing = request.routing() != null ? request.routing() : request.id();

        // 2. 计算分片ID
        ClusterState clusterState = clusterService.state();
        IndexMetadata indexMetadata = clusterState.metadata().index(request.index());
        int shardId = routing.hashCode() % indexMetadata.getNumberOfShards();

        // 3. 查找Primary Shard位置
        ShardRouting primaryShard = clusterState.routingTable()
            .shardRoutingTable(request.index(), shardId)
            .primaryShard();

        String nodeId = primaryShard.currentNodeId();

        // 4. 转发到Primary Shard节点
        if (clusterService.localNode().getId().equals(nodeId)) {
            // 本地执行
            shardOperationOnPrimary(request, primary, listener);
        } else {
            // 远程执行
            transportService.sendRequest(
                clusterState.nodes().get(nodeId),
                "indices:data/write/index[p]",
                request,
                new TransportResponseHandler<IndexResponse>() {
                    // 处理响应
                }
            );
        }
    }
}

public class IndexShard extends AbstractIndexShardComponent {
    public Engine.IndexResult index(Engine.Index index) {
        // 1. 前置检查
        ensureWriteAllowed(index);
        verifyNotClosed();

        // 2. 分配序列号
        long seqNo = seqNoStats().getMaxSeqNo() + 1;
        long primaryTerm = this.primaryTerm;

        // 3. 更新操作
        index.seqNo(seqNo);
        index.primaryTerm(primaryTerm);

        // 4. 执行写入
        Engine.IndexResult result = engine.index(index);

        return result;
    }
}

public class InternalEngine extends Engine {
    @Override
    public IndexResult index(Index index) {
        // 1. 获取UID锁
        try (Releasable ignored = versionMap.acquireLock(index.uid())) {

            // 2. 获取当前版本
            VersionValue versionValue = versionMap.getUnderLock(index.uid());
            long currentVersion = versionValue != null ? versionValue.version : Versions.NOT_FOUND;

            // 3. 版本冲突检测
            if (index.versionType().isVersionConflictForWrites(
                    currentVersion, index.version(), index.versionType())) {
                return new IndexResult(
                    new VersionConflictEngineException(...)
                );
            }

            // 4. 计算新版本
            long newVersion = index.versionType().updateVersion(currentVersion, index.version());

            // 5. 写入Lucene和Translog
            // ...
        }
    }
}

// 新文档
if (plan.useLuceneUpdateDocument == false) {
    indexWriter.addDocument(index.docs());
} else {
    // 更新文档(先删除后添加)
    indexWriter.updateDocument(
        new Term(IdFieldMapper.NAME, index.uid()),
        index.docs()
    );
}

// 写入Translog
Translog.Location location = translog.add(new Translog.Index(index));

// 根据持久化策略刷盘
if (translog.getDurability() == Translog.Durability.REQUEST) {
    translog.sync();  // 同步刷盘
} else {
    // ASYNC模式,异步刷盘(默认5秒)
}

versionMap.putIndexUnderLock(
    index.uid(),
    new IndexVersionValue(
        location,      // Translog位置
        newVersion,    // 新版本号
        index.seqNo(), // 序列号
        index.primaryTerm()  // 主分片任期
    )
);

// 并行复制到所有副本
for (ShardRouting replicaShard : replicaShards) {
    transportService.sendRequest(
        clusterState.nodes().get(replicaShard.currentNodeId()),
        "indices:data/write/index[r]",  // 副本操作
        new ReplicaRequest(indexRequest, seqNo, primaryTerm),
        new TransportResponseHandler<ReplicaResponse>() {
            @Override
            public void handleResponse(ReplicaResponse response) {
                // 副本确认
                replicaResponses.add(response);
                checkAllReplicasResponded();
            }
        }
    );
}

// 副本节点收到复制请求
public void indexReplica(ReplicaRequest request) {
    // 使用Primary分配的seqNo
    Index operation = new Index(...);
    operation.seqNo(request.seqNo());
    operation.primaryTerm(request.primaryTerm());

    // 执行写入(无需版本检查)
    engine.index(operation);
}

IndexResponse response = new IndexResponse(
    shardId,
    indexRequest.id(),
    result.getSeqNo(),
    result.getPrimaryTerm(),
    result.getVersion(),
    result.isCreated()  // true表示新建,false表示更新
);

// 返回JSON
{
  "_index": "my-index",
  "_id": "1",
  "_version": 1,
  "_seq_no": 0,
  "_primary_term": 1,
  "result": "created"  // or "updated"
}