stateDiagram-v2
    [*] --> NotStarted: Erlang VM 启动
    NotStarted --> Booting: rabbit:start() / rabbit:boot()
    
    Booting --> PrelaunchPhase1: 启动 rabbitmq_prelaunch
    PrelaunchPhase1 --> PrelaunchPhase2: 解析配置与上下文
    PrelaunchPhase2 --> PrelaunchPhase2: 1. 特性标志初始化
    PrelaunchPhase2 --> PrelaunchPhase2: 2. 日志系统初始化
    PrelaunchPhase2 --> PrelaunchPhase2: 3. Khepri/Ra 系统启动
    PrelaunchPhase2 --> PrelaunchPhase2: 4. 集群检查
    PrelaunchPhase2 --> PrelaunchPhase2: 5. Mnesia 启动（如适用）
    
    PrelaunchPhase2 --> CoreStarting: rabbit:start/2 回调
    CoreStarting --> CoreStarting: 1. 创建 rabbit_sup
    CoreStarting --> CoreStarting: 2. 注册 rabbit 进程名
    CoreStarting --> CoreStarting: 3. 加载插件
    CoreStarting --> CoreStarting: 4. 刷新特性标志
    CoreStarting --> CoreStarting: 5. 运行 boot steps
    
    CoreStarting --> CoreStarted: boot steps 完成
    CoreStarted --> PostlaunchPhase: 后启动阶段
    PostlaunchPhase --> PostlaunchPhase: 1. 启动插件应用
    PostlaunchPhase --> PostlaunchPhase: 2. 通知节点上线
    PostlaunchPhase --> PostlaunchPhase: 3. 恢复虚拟主机
    PostlaunchPhase --> PostlaunchPhase: 4. 启动网络监听
    
    PostlaunchPhase --> Ready: 标记为 ready
    Ready --> Running: 正常服务
    
    Running --> Stopping: rabbit:stop()
    Stopping --> Stopped: 清理资源
    Stopped --> [*]
    
    Running --> PrepStopping: rabbit:prep_stop/1
    PrepStopping --> Stopping: 停止接受连接

flowchart TB
    subgraph "应用入口"
        Start[rabbit:start/0<br/>rabbit:boot/0]
        StartIt[start_it/1<br/>启动协调]
        Start --> StartIt
    end
    
    subgraph "预启动阶段"
        PrelaunchApp[rabbitmq_prelaunch<br/>应用启动]
        RunPrelaunch2[run_prelaunch_second_phase/0]
        
        PrelaunchApp --> RunPrelaunch2
        
        EnabledPlugins[启用插件文件处理]
        FeatureFlagsSetup[特性标志注册表初始化]
        LoggingSetup[日志系统设置]
        RaSystems[Ra 系统启动]
        KhepriSetup[Khepri 启动]
        ClusterCheck[集群检查与兼容性验证]
        MnesiaStart[Mnesia 启动<br/>如不使用 Khepri]
        
        RunPrelaunch2 --> EnabledPlugins
        EnabledPlugins --> FeatureFlagsSetup
        FeatureFlagsSetup --> LoggingSetup
        LoggingSetup --> RaSystems
        RaSystems --> KhepriSetup
        KhepriSetup --> ClusterCheck
        ClusterCheck --> MnesiaStart
    end
    
    subgraph "核心启动阶段"
        RabbitStart[rabbit:start/2<br/>application 回调]
        CreateSup[创建 rabbit_sup<br/>监督树根]
        RegisterName[注册 rabbit 进程名]
        LoadPlugins[加载插件应用]
        RefreshFF[刷新特性标志]
        RunBootSteps[运行 boot steps<br/>rabbit_boot_steps:run_boot_steps/1]
        
        RabbitStart --> CreateSup
        CreateSup --> RegisterName
        RegisterName --> LoadPlugins
        LoadPlugins --> RefreshFF
        RefreshFF --> RunBootSteps
    end
    
    subgraph "Boot Steps"
        direction TB
        PreBoot[pre_boot]
        CodecCheck[codec_correctness_check]
        DatabaseInit[database<br/>rabbit_db:init/0]
        FileHandles[file_handle_cache<br/>启动文件句柄缓存]
        WorkerPool[worker_pool<br/>启动工作进程池]
        ExternalInfra[external_infrastructure<br/>启动网络/日志等]
        Recovery[recovery<br/>队列与交换器恢复]
        RoutingReady[routing_ready<br/>路由系统就绪]
        LogExchange[log_exchange<br/>日志交换器]
        DirectClient[direct_client<br/>内部客户端支持]
        NetworkingMetadata[networking_metadata<br/>网络元数据初始化]
        Notify[notify_cluster<br/>通知集群节点上线]
        
        PreBoot --> CodecCheck
        CodecCheck --> DatabaseInit
        DatabaseInit --> FileHandles
        FileHandles --> WorkerPool
        WorkerPool --> ExternalInfra
        ExternalInfra --> Recovery
        Recovery --> RoutingReady
        RoutingReady --> LogExchange
        LogExchange --> DirectClient
        DirectClient --> NetworkingMetadata
        NetworkingMetadata --> Notify
    end
    
    subgraph "后启动阶段"
        PostlaunchPhase[run_postlaunch_phase/1]
        StartPluginApps[启动插件应用]
        NotifyUp[通知节点上线<br/>rabbit_node_monitor]
        RecoverVHosts[恢复虚拟主机<br/>rabbit_vhosts:boot/0]
        StartListeners[启动网络监听器<br/>rabbit_networking:boot/0]
        SetReady[标记状态为 ready<br/>rabbit_boot_state:set/1]
        
        PostlaunchPhase --> StartPluginApps
        StartPluginApps --> NotifyUp
        NotifyUp --> RecoverVHosts
        RecoverVHosts --> StartListeners
        StartListeners --> SetReady
    end
    
    StartIt --> PrelaunchApp
    MnesiaStart --> RabbitStart
    RunBootSteps --> PostlaunchPhase
    SetReady --> Ready[运行中<br/>ready state]

-spec start() -> 'ok'.

start() ->
    %% start() vs. boot(): we want to throw an error in start().
    start_it(temporary).

start_it(StartType) ->
    case spawn_boot_marker() of
        {ok, Marker} ->
            ?LOG_INFO("RabbitMQ is asked to start...", []),
            try
                {Millis, ok} = timer:tc(
                    fun() ->
                        %% 1. 启动预启动应用
                        {ok, _} = application:ensure_all_started(
                                    rabbitmq_prelaunch, StartType),
                        %% 2. 启动 rabbit 应用
                        {ok, _} = application:ensure_all_started(
                                    rabbit, StartType),
                        %% 3. 等待启动完成或停止
                        wait_for_ready_or_stopped()
                    end, millisecond),
                ?LOG_INFO("Time to start RabbitMQ: ~b ms", [Millis]),
                stop_boot_marker(Marker),
                ok
            catch
                error:{badmatch, Error}:_ ->
                    %% 失败时停止预启动应用并清理
                    _ = application:stop(rabbitmq_prelaunch),
                    stop_boot_marker(Marker),
                    case StartType of
                        temporary -> throw(Error);  %% 抛出异常
                        _         -> exit(Error)    %% 退出节点
                    end
            end;
        {already_booting, Marker} ->
            %% 已在启动中，等待完成
            stop_boot_marker(Marker),
            ok
    end.

sequenceDiagram
    autonumber
    participant User as 用户/CLI
    participant Rabbit as rabbit 模块
    participant PrelaunchApp as rabbitmq_prelaunch
    participant AppCtl as application 控制器
    participant BootState as rabbit_boot_state
    
    User->>+Rabbit: start()
    Rabbit->>Rabbit: spawn_boot_marker()<br/>注册 rabbit_boot 进程
    
    alt 首次启动
        Rabbit->>+PrelaunchApp: application:ensure_all_started(rabbitmq_prelaunch)
        PrelaunchApp->>PrelaunchApp: 解析配置与环境
        PrelaunchApp->>PrelaunchApp: 创建上下文
        PrelaunchApp-->>-Rabbit: {ok, [rabbitmq_prelaunch]}
        
        Rabbit->>+AppCtl: application:ensure_all_started(rabbit)
        AppCtl->>Rabbit: start(normal, [])<br/>回调
        Note over Rabbit: 详见 start/2 时序图
        AppCtl-->>-Rabbit: {ok, [rabbit, ...]}
        
        Rabbit->>+BootState: wait_for_ready_or_stopped()
        BootState->>BootState: 轮询状态<br/>间隔 100ms
        BootState-->>-Rabbit: ok (状态为 ready)
        
        Rabbit->>Rabbit: stop_boot_marker()<br/>注销 rabbit_boot 进程
        Rabbit-->>-User: ok
    else 已在启动中
        Rabbit->>Rabbit: spawn_boot_marker()<br/>失败（已存在）
        Rabbit->>Rabbit: stop_boot_marker()
        Rabbit-->>User: ok
    end

-spec boot() -> 'ok'.

boot() ->
    %% start() vs. boot(): we want the node to exit in boot(). Because
    %% applications are started with `transient`, any error during their
    %% startup will abort the node.
    start_it(transient).

sequenceDiagram
    autonumber
    participant SystemD as systemd/启动脚本
    participant Rabbit as rabbit 模块
    participant BEAM as Erlang VM
    
    SystemD->>+Rabbit: boot()
    Rabbit->>Rabbit: start_it(transient)
    
    alt 启动成功
        Rabbit-->>-SystemD: ok
    else 启动失败
        Rabbit->>+BEAM: exit(Error)
        BEAM->>BEAM: 终止 VM
        BEAM-->>-SystemD: 退出码 非 0
        SystemD->>SystemD: 重启服务<br/>根据 systemd 配置
    end

-spec stop() -> 'ok'.

stop() ->
    case wait_for_ready_or_stopped() of
        ok ->
            ?LOG_INFO("Stopping RabbitMQ", []),
            %% 1. 停止插件应用
            Plugins = rabbit_plugins:active(),
            stop_apps(Plugins),
            %% 2. 停止 rabbit 应用
            rabbit_prelaunch:set_stop_reason(stop),
            ok = application:stop(rabbit),
            %% 3. 停止预启动应用
            ok = application:stop(rabbitmq_prelaunch),
            ?LOG_INFO("Stopped RabbitMQ application", []);
        {error, _} = Error ->
            Error
    end.

sequenceDiagram
    autonumber
    participant User as 用户/CLI
    participant Rabbit as rabbit 模块
    participant PluginMgr as rabbit_plugins
    participant AppCtl as application 控制器
    participant RabbitSup as rabbit_sup
    participant Children as 各子系统
    
    User->>+Rabbit: stop()
    Rabbit->>Rabbit: wait_for_ready_or_stopped()
    
    Rabbit->>+PluginMgr: active()
    PluginMgr-->>-Rabbit: [plugin1, plugin2, ...]
    
    loop 每个插件（倒序）
        Rabbit->>+AppCtl: application:stop(PluginN)
        AppCtl->>AppCtl: 触发 cleanup steps
        AppCtl->>AppCtl: 停止插件监督树
        AppCtl-->>-Rabbit: ok
    end
    
    Rabbit->>+AppCtl: application:stop(rabbit)
    AppCtl->>+Rabbit: prep_stop(State)<br/>预停止回调
    Rabbit->>Rabbit: 停止接受新连接
    Rabbit->>Rabbit: 关闭监听器
    Rabbit-->>-AppCtl: State
    
    AppCtl->>+Rabbit: stop(State)<br/>停止回调
    Rabbit->>+RabbitSup: supervisor:terminate_child(...)
    RabbitSup->>+Children: 逐个停止子进程
    Children->>Children: 保存状态（如队列索引）
    Children->>Children: 关闭连接/文件
    Children-->>-RabbitSup: ok
    RabbitSup-->>-Rabbit: ok
    Rabbit-->>-AppCtl: ok
    AppCtl-->>-Rabbit: ok
    
    Rabbit->>+AppCtl: application:stop(rabbitmq_prelaunch)
    AppCtl->>AppCtl: 清理上下文
    AppCtl-->>-Rabbit: ok
    
    Rabbit-->>-User: ok

-spec start('normal', []) ->
    {'error',
     {'erlang_version_too_old',
      {'found', string(), string()},
      {'required', string(), string()}}} |
    {'ok', pid()}.

start(normal, []) ->
    %% 1. 重置启动状态为 booting
    rabbit_boot_state:set(booting),
    rabbit_prelaunch:clear_stop_reason(),
    
    try
        %% 2. 运行预启动第二阶段
        run_prelaunch_second_phase(),
        
        %% 3. 打印产品信息
        ProductInfo = product_info(),
        ?LOG_INFO(
           "~n Starting ~ts ~ts on Erlang ~ts [~ts]~n ~ts~n ~ts",
           [product_name(), product_version(), rabbit_misc:otp_release(),
            emu_flavor(), ?COPYRIGHT_MESSAGE, product_license_line()]),
        log_motd(),
        
        %% 4. 创建根监督者
        {ok, SupPid} = rabbit_sup:start_link(),
        
        %% 5. 启动特性标志控制器（如启用 feature_flags_v2）
        ok = rabbit_sup:start_child(rabbit_ff_controller),
        
        %% 6. 注册 rabbit 进程名（用于远程节点检查）
        true = register(rabbit, self()),
        
        print_banner(),
        log_banner(),
        warn_if_kernel_config_dubious(),
        
        %% 7. 设置插件
        Plugins = rabbit_plugins:setup(),
        ?LOG_DEBUG("Loading the following plugins: ~tp", [Plugins]),
        ok = app_utils:load_applications(Plugins),
        
        %% 8. 刷新特性标志（包括插件的）
        case rabbit_feature_flags:refresh_feature_flags_after_app_load() of
            ok     -> ok;
            Error1 -> throw(Error1)
        end,
        
        persist_static_configuration(),
        
        %% 9. 运行 boot steps
        ok = rabbit_boot_steps:run_boot_steps([rabbit | Plugins]),
        rabbit_boot_state:set(core_started),
        
        %% 10. 运行后启动阶段
        run_postlaunch_phase(Plugins),
        {ok, SupPid}
    catch
        throw:{error, _} = Error ->
            _ = mnesia:stop(),
            rabbit_prelaunch:set_stop_reason(Error),
            rabbit_boot_state:set(stopped),
            Error
    end.

sequenceDiagram
    autonumber
    participant AppCtl as Application Controller
    participant Rabbit as rabbit:start/2
    participant Prelaunch as run_prelaunch_second_phase
    participant RabbitSup as rabbit_sup
    participant BootSteps as rabbit_boot_steps
    participant DB as rabbit_db
    participant Plugins as plugin applications
    participant Postlaunch as run_postlaunch_phase
    
    AppCtl->>+Rabbit: start(normal, [])
    Rabbit->>Rabbit: rabbit_boot_state:set(booting)
    
    Rabbit->>+Prelaunch: run_prelaunch_second_phase()
    Prelaunch->>Prelaunch: 启用插件文件处理
    Prelaunch->>Prelaunch: 特性标志注册表初始化
    Prelaunch->>Prelaunch: 日志系统设置
    Prelaunch->>Prelaunch: Ra 系统启动
    Prelaunch->>Prelaunch: Khepri 启动
    Prelaunch->>Prelaunch: 集群检查
    Prelaunch->>Prelaunch: Mnesia 启动（如适用）
    Prelaunch-->>-Rabbit: ok
    
    Rabbit->>+RabbitSup: start_link()
    RabbitSup->>RabbitSup: 初始化监督者<br/>one_for_all 策略
    RabbitSup-->>-Rabbit: {ok, SupPid}
    
    Rabbit->>Rabbit: register(rabbit, self())
    Rabbit->>Rabbit: rabbit_plugins:setup()<br/>获取插件列表
    Rabbit->>Rabbit: app_utils:load_applications(Plugins)
    Rabbit->>Rabbit: refresh_feature_flags_after_app_load()
    
    Rabbit->>+BootSteps: run_boot_steps([rabbit | Plugins])
    
    loop 每个 boot step（拓扑排序）
        BootSteps->>BootSteps: 检查 requires 依赖
        BootSteps->>+DB: 示例: rabbit_db:init()
        DB->>DB: 初始化数据库<br/>创建表结构
        DB-->>-BootSteps: ok
    end
    
    BootSteps-->>-Rabbit: ok
    Rabbit->>Rabbit: rabbit_boot_state:set(core_started)
    
    Rabbit->>+Postlaunch: run_postlaunch_phase(Plugins)
    
    loop 每个插件
        Postlaunch->>+Plugins: application:ensure_all_started(PluginN)
        Plugins->>Plugins: 启动插件监督树
        Plugins->>Plugins: 插件 boot steps
        Plugins-->>-Postlaunch: {ok, [PluginN | Deps]}
    end
    
    Postlaunch->>Postlaunch: rabbit_node_monitor:notify_node_up()
    Postlaunch->>Postlaunch: rabbit_vhosts:boot()<br/>恢复虚拟主机
    Postlaunch->>Postlaunch: rabbit_networking:boot()<br/>启动监听器
    Postlaunch->>Postlaunch: rabbit_boot_state:set(ready)
    Postlaunch-->>-Rabbit: ok
    
    Rabbit-->>-AppCtl: {ok, SupPid}

-spec stop(term()) -> 'ok'.

stop(State) ->
    ok = rabbit_alarm:stop(),
    ok = case rabbit_mnesia:is_clustered() of
             true  -> ok;
             false -> rabbit_table:clear_ram_only_tables()
         end,
    ok = rabbit_boot_state:set(stopped),
    State.

sequenceDiagram
    participant AppCtl as Application Controller
    participant Rabbit as rabbit 模块
    participant RabbitSup as rabbit_sup
    
    AppCtl->>+Rabbit: prep_stop(State)
    Note over Rabbit: 预停止阶段<br/>停止接受新连接
    Rabbit->>Rabbit: 关闭监听器
    Rabbit->>Rabbit: 等待连接关闭（有超时）
    Rabbit-->>-AppCtl: NewState
    
    AppCtl->>+RabbitSup: supervisor:terminate_child(...)
    Note over RabbitSup: 停止所有子进程<br/>（网络、队列、交换器等）
    RabbitSup-->>-AppCtl: ok
    
    AppCtl->>+Rabbit: stop(NewState)
    Note over Rabbit: 最终清理
    Rabbit->>Rabbit: 停止告警系统
    Rabbit->>Rabbit: 清理内存表
    Rabbit->>Rabbit: 设置状态为 stopped
    Rabbit-->>-AppCtl: ok

-spec prep_stop(term()) -> term().

prep_stop(State) ->
    rabbit_alarm:unregister(self()),
    Listeners = rabbit_networking:stop(),
    ok = rabbit_boot_state:set(stopping),
    rabbit_boot_state:wait_for_exit(),
    %% Saved so we can try to avoid stalling shutdown.
    %% See rabbit_mnesia:remove_node_offline/1.
    rabbit_nodes:ensure_written(),
    State.

%% 启动类型
-type restart_type() :: 'permanent' | 'transient' | 'temporary'.

%% 应用参数
-type param() :: atom().
-type app_name() :: atom().

%% 产品信息
-type product_info() :: #{
    product_name := string(),
    product_version := string(),
    product_base_name => string(),
    product_base_version => string(),
    product_overridden => boolean()
}.

stateDiagram-v2
    [*] --> booting: start/2 调用
    booting --> core_started: boot steps 完成
    core_started --> ready: 后启动阶段完成
    ready --> stopping: prep_stop/1 调用
    stopping --> stopped: stop/1 完成
    stopped --> [*]
    
    booting --> stopped: 启动失败
    core_started --> stopped: 后启动失败

classDiagram
    class rabbit {
        <<module>>
        +start() ok
        +boot() ok
        +stop() ok
        +start(normal, []) {ok, pid()}
        +prep_stop(State) State
        +stop(State) ok
        +status() status_map()
        +is_running() boolean()
        +is_serving() boolean()
        -start_it(restart_type()) ok
        -run_prelaunch_second_phase() ok
        -run_postlaunch_phase([app_name()]) ok
        -spawn_boot_marker() {ok, pid()} | {already_booting, pid()}
        -wait_for_ready_or_stopped() ok
    }
    
    class rabbit_boot_state {
        <<module>>
        +set(State) ok
        +get() State
        +wait_for(State, Timeout) ok | {error, timeout}
        +has_reached(State) boolean()
    }
    
    class rabbit_sup {
        <<supervisor>>
        +start_link() {ok, pid()}
        +start_child(Module) ok
    }
    
    class rabbit_boot_steps {
        <<module>>
        +run_boot_steps([app_name()]) ok
        +run_cleanup_steps([app_name()]) ok
        +find_steps() [{app_name(), step_name(), attributes()}]
        -sort_boot_steps([step_def()]) [step_def()]
    }
    
    class rabbit_plugins {
        <<module>>
        +setup() [app_name()]
        +active() [app_name()]
    }
    
    rabbit --> rabbit_boot_state : uses
    rabbit --> rabbit_sup : creates
    rabbit --> rabbit_boot_steps : uses
    rabbit --> rabbit_plugins : uses
    rabbit_boot_steps --> rabbit : callbacks (boot step MFAs)

-rabbit_boot_step({step_name,
                   [{description, "Human readable description"},
                    {mfa, {Module, Function, Args}},  %% 执行的函数
                    {requires, [other_step1, other_step2]},  %% 依赖步骤
                    {enables, [enabled_step1]}]}).  %% 启用步骤

graph TD
    pre_boot[pre_boot]
    codec[codec_correctness_check]
    fhc[file_handle_cache]
    pool[worker_pool]
    db[database]
    infra[external_infrastructure]
    registry[rabbit_registry]
    recovery[recovery]
    routing[routing_ready]
    log[log_exchange]
    direct[direct_client]
    net[networking]
    notify[notify_cluster]
    
    pre_boot --> codec
    pre_boot --> fhc
    pre_boot --> pool
    fhc --> db
    db --> infra
    db --> recovery
    infra --> registry
    infra --> direct
    recovery --> routing
    routing --> log
    direct --> net
    net --> notify

-rabbit_boot_step({database,
                   [{description, "database"},
                    {mfa, {rabbit_db, init, []}},
                    {requires, file_handle_cache},
                    {enables, external_infrastructure}]}).

init() ->
    %% 1. 确定使用的数据库（Mnesia 或 Khepri）
    Backend = case rabbit_khepri:is_enabled() of
                  true  -> khepri;
                  false -> mnesia
              end,
    
    %% 2. 等待表/数据可用
    case Backend of
        mnesia ->
            ok = rabbit_table:wait_for_replicated(),
            ok = rabbit_table:wait(rabbit_user:pattern_match_all());
        khepri ->
            ok = rabbit_khepri:wait_for_store()
    end,
    
    %% 3. 执行数据迁移（如需要）
    case rabbit_feature_flags:is_enabled(khepri_db) of
        true ->
            ok = rabbit_db_m2k_converter:sync_if_needed();
        false ->
            ok
    end,
    
    %% 4. 初始化各数据层模块
    ok = rabbit_db_cluster:init(),
    ok = rabbit_db_user:init(),
    ok = rabbit_db_vhost:init(),
    ok = rabbit_db_exchange:init(),
    ok = rabbit_db_queue:init(),
    ok = rabbit_db_binding:init(),
    ok.

-rabbit_boot_step({recovery,
                   [{description, "recovery"},
                    {mfa, {rabbit, recover, []}},
                    {requires, database},
                    {enables, routing_ready}]}).

recover() ->
    %% 1. 恢复所有虚拟主机的交换器
    [rabbit_exchange:recover(VHost) || VHost <- rabbit_vhost:list_names()],
    
    %% 2. 恢复所有虚拟主机的队列
    [begin
        Queues = rabbit_amqqueue:list(VHost),
        [rabbit_amqqueue:recover(Q) || Q <- Queues]
     end || VHost <- rabbit_vhost:list_names()],
    
    ok.

sequenceDiagram
    participant BS as Boot Steps
    participant Recover as rabbit:recover/0
    participant Exchange as rabbit_exchange
    participant Queue as rabbit_amqqueue
    participant QProc as Queue 进程
    
    BS->>+Recover: recover()
    
    loop 每个虚拟主机
        Recover->>+Exchange: recover(VHost)
        Exchange->>Exchange: 从数据库加载交换器
        Exchange->>Exchange: 应用 policies
        Exchange-->>-Recover: [ExchangeNames]
        
        Recover->>+Queue: list(VHost)
        Queue->>Queue: 从数据库加载队列定义
        Queue-->>-Recover: [Queues]
        
        loop 每个队列
            Recover->>+Queue: recover(Queue)
            Queue->>+QProc: 启动队列进程
            QProc->>QProc: 恢复消息索引
            QProc->>QProc: 重建状态
            QProc-->>-Queue: {ok, QPid}
            Queue-->>-Recover: ok
        end
    end
    
    Recover-->>-BS: ok

boot() ->
    %% 1. 读取监听器配置
    Listeners = application:get_env(rabbit, tcp_listeners, [5672]),
    SSLListeners = application:get_env(rabbit, ssl_listeners, []),
    
    %% 2. 启动 TCP 监听器
    [begin
        {ok, _} = rabbit_networking:start_tcp_listener(Address, Port, Opts)
     end || {Address, Port, Opts} <- Listeners],
    
    %% 3. 启动 TLS 监听器
    [begin
        {ok, _} = rabbit_networking:start_ssl_listener(Address, Port, Opts)
     end || {Address, Port, Opts} <- SSLListeners],
    
    ok.

run_postlaunch_phase(Plugins) ->
    ?LOG_DEBUG(""),
    ?LOG_DEBUG("== Postlaunch phase =="),
    
    %% 1. 启动插件应用
    ?LOG_DEBUG("Starting plugin applications"),
    start_apps(Plugins, #{}),
    
    %% 2. 通知节点上线
    rabbit_node_monitor:notify_node_up(),
    
    %% 3. 恢复虚拟主机
    rabbit_vhosts:boot(),
    
    %% 4. 启动网络监听器
    rabbit_networking:boot(),
    
    %% 5. 标记为 ready
    rabbit_boot_state:set(ready),
    ?LOG_INFO("Server startup complete; ~b plugins started.", [length(Plugins)]),
    
    ok.

sequenceDiagram
    autonumber
    participant Start as rabbit:start/2
    participant Post as run_postlaunch_phase
    participant Plugins as Plugin Applications
    participant NodeMon as rabbit_node_monitor
    participant VHosts as rabbit_vhosts
    participant Net as rabbit_networking
    participant State as rabbit_boot_state
    
    Start->>+Post: run_postlaunch_phase(Plugins)
    
    loop 每个插件
        Post->>+Plugins: start_apps([Plugin])
        Plugins->>Plugins: application:ensure_all_started
        Plugins->>Plugins: 运行插件 boot steps
        Plugins-->>-Post: ok
    end
    
    Post->>+NodeMon: notify_node_up()
    NodeMon->>NodeMon: 通知集群节点<br/>本节点已上线
    NodeMon->>NodeMon: 建立节点监控
    NodeMon-->>-Post: ok
    
    Post->>+VHosts: boot()
    VHosts->>VHosts: 确保每个 vhost<br/>有运行的进程
    VHosts->>VHosts: 协调多节点 vhost 进程
    VHosts-->>-Post: ok
    
    Post->>+Net: boot()
    Net->>Net: 启动 TCP 监听器
    Net->>Net: 启动 TLS 监听器
    Net->>Net: 注册协议处理器
    Net-->>-Post: ok
    
    Post->>+State: set(ready)
    State->>State: 写入 ETS 表
    State->>State: 通知等待进程
    State-->>-Post: ok
    
    Post-->>-Start: ok

用户调用 rabbit:start/0
  └─> start_it(temporary)
      ├─> spawn_boot_marker()  // 注册 rabbit_boot 进程
      ├─> application:ensure_all_started(rabbitmq_prelaunch)
      │   └─> rabbitmq_prelaunch:start/2
      │       ├─> 解析配置文件
      │       ├─> 创建上下文
      │       └─> 设置环境变量
      │
      ├─> application:ensure_all_started(rabbit)
      │   └─> rabbit:start(normal, [])
      │       ├─> rabbit_boot_state:set(booting)
      │       │
      │       ├─> run_prelaunch_second_phase()
      │       │   ├─> rabbit_prelaunch_enabled_plugins_file:setup()
      │       │   ├─> rabbit_prelaunch_feature_flags:setup()
      │       │   ├─> rabbit_prelaunch_logging:setup()
      │       │   ├─> rabbit_ra_systems:setup()
      │       │   ├─> rabbit_khepri:setup()
      │       │   ├─> rabbit_prelaunch_cluster:setup()
      │       │   └─> mnesia:start() (如不使用 Khepri)
      │       │
      │       ├─> rabbit_sup:start_link()
      │       │   └─> supervisor:init([])
      │       │       └─> 初始化监督者（one_for_all）
      │       │
      │       ├─> register(rabbit, self())
      │       │
      │       ├─> rabbit_plugins:setup()
      │       │   ├─> 读取 enabled_plugins 文件
      │       │   └─> 按依赖顺序排列插件
      │       │
      │       ├─> app_utils:load_applications(Plugins)
      │       │
      │       ├─> rabbit_feature_flags:refresh_feature_flags_after_app_load()
      │       │   ├─> 扫描模块属性
      │       │   ├─> 注册新特性标志
      │       │   └─> 检查兼容性
      │       │
      │       ├─> rabbit_boot_steps:run_boot_steps([rabbit | Plugins])
      │       │   ├─> find_steps([rabbit | Plugins])
      │       │   │   ├─> 扫描模块属性（-rabbit_boot_step）
      │       │   │   └─> sort_boot_steps()
      │       │   │       └─> 拓扑排序（digraph_utils:topsort）
      │       │   │
      │       │   └─> for each step:
      │       │       ├─> run_step(Attributes, mfa)
      │       │       └─> apply(M, F, A)
      │       │           例如:
      │       │           ├─> rabbit_db:init()
      │       │           ├─> rabbit:start_fhc()
      │       │           ├─> rabbit:recover()
      │       │           └─> ...
      │       │
      │       ├─> rabbit_boot_state:set(core_started)
      │       │
      │       └─> run_postlaunch_phase(Plugins)
      │           ├─> start_apps(Plugins, #{})
      │           │   └─> for each plugin:
      │           │       ├─> app_utils:load_applications([Plugin])
      │           │       ├─> rabbit_boot_steps:run_boot_steps([Plugin])
      │           │       └─> application:ensure_all_started(Plugin)
      │           │
      │           ├─> rabbit_node_monitor:notify_node_up()
      │           ├─> rabbit_vhosts:boot()
      │           ├─> rabbit_networking:boot()
      │           └─> rabbit_boot_state:set(ready)
      │
      └─> wait_for_ready_or_stopped()
          └─> rabbit_boot_state:wait_for(ready, 12h)
              └─> 轮询检查状态，间隔 100ms

%% 检查运行状态
rabbit:is_running().
%% => true | false

%% 检查服务状态（是否接受连接）
rabbit:is_serving().
%% => true | false

%% 获取详细状态
rabbit:status().
%% => #{
%%     pid => <0.123.0>,
%%     running_applications => [...],
%%     listeners => [{port, 5672}, ...],
%%     alarms => []
%% }

%% Erlang shell
application:stop(rabbitmq_prelaunch).
application:stop(rabbit).
%% 然后重新启动
rabbit:start().

# 查看插件状态
rabbitmq-plugins list
# 禁用有问题的插件
rabbitmq-plugins disable <plugin_name>
# 重新启动
rabbitmqctl stop_app
rabbitmqctl start_app

#!/bin/bash
# 监控启动进度
while ! rabbitmqctl await_online_nodes 1; do
    echo "Waiting for node to come online..."
    sleep 1
done

rabbitmqctl await_startup
echo "RabbitMQ startup complete!"

sequenceDiagram
    autonumber
    participant User
    participant Rabbit as rabbit:start/0
    participant Mnesia
    participant DB as rabbit_db
    participant VHost as rabbit_vhost
    
    User->>+Rabbit: start()
    Rabbit->>Rabbit: 预启动阶段
    Rabbit->>+Mnesia: mnesia:start()
    Mnesia->>Mnesia: 检测首次启动<br/>无数据目录
    Mnesia->>Mnesia: 创建 schema
    Mnesia-->>-Rabbit: ok
    
    Rabbit->>+DB: init() (boot step)
    DB->>Mnesia: 创建表<br/>rabbit_user, rabbit_vhost, etc.
    Mnesia->>Mnesia: 创建磁盘表<br/>rabbit_durable_queue
    Mnesia->>Mnesia: 创建内存表<br/>rabbit_route
    Mnesia-->>DB: ok
    DB-->>-Rabbit: ok
    
    Rabbit->>+DB: maybe_insert_default_data() (boot step)
    DB->>+VHost: add(<<"/">>, #{})
    VHost->>Mnesia: 插入默认 vhost
    VHost-->>-DB: ok
    DB->>DB: 创建默认用户 "guest"
    DB->>DB: 设置默认权限
    DB-->>-Rabbit: ok
    
    Rabbit->>Rabbit: 后续 boot steps
    Rabbit->>Rabbit: 后启动阶段
    Rabbit-->>-User: ok

sequenceDiagram
    autonumber
    participant CLI
    participant NewNode as 新节点 rabbit
    participant ExistingNode as 已有节点 rabbit
    participant Mnesia
    
    Note over NewNode: 初始启动（单节点）
    CLI->>+NewNode: start()
    NewNode->>NewNode: 预启动阶段
    NewNode-->>-CLI: ok (单节点集群)
    
    Note over NewNode,ExistingNode: 加入集群
    CLI->>+NewNode: stop_app()
    NewNode->>NewNode: 停止应用<br/>保留 Mnesia
    NewNode-->>-CLI: ok
    
    CLI->>+NewNode: join_cluster(ExistingNode)
    NewNode->>+Mnesia: change_config(extra_db_nodes, [ExistingNode])
    Mnesia->>+ExistingNode: 请求集群信息
    ExistingNode->>ExistingNode: 检查兼容性<br/>特性标志一致性
    ExistingNode-->>-Mnesia: cluster_info
    Mnesia->>Mnesia: 复制表定义
    Mnesia-->>-NewNode: ok
    NewNode-->>-CLI: ok
    
    CLI->>+NewNode: start_app()
    NewNode->>NewNode: 预启动阶段<br/>（检测到集群配置）
    NewNode->>+ExistingNode: 同步元数据
    ExistingNode-->>-NewNode: queues, exchanges, bindings
    NewNode->>NewNode: Boot steps
    NewNode->>NewNode: 后启动阶段
    NewNode->>+ExistingNode: notify_node_up()
    ExistingNode->>ExistingNode: 更新集群视图
    ExistingNode-->>-NewNode: ok
    NewNode-->>-CLI: ok

sequenceDiagram
    autonumber
    participant CLI
    participant Rabbit as rabbit:stop/0
    participant Net as rabbit_networking
    participant Conn as 客户端连接
    participant Queue as 队列进程
    participant Mnesia
    
    CLI->>+Rabbit: stop()
    
    Rabbit->>+Net: stop()
    Net->>Net: 关闭监听器<br/>拒绝新连接
    Net->>+Conn: 发送连接关闭帧<br/>connection.close
    Conn->>Conn: 客户端处理关闭
    Conn-->>-Net: connection.close-ok
    Net-->>-Rabbit: ok
    
    Rabbit->>Rabbit: application:stop(rabbit)
    Rabbit->>Rabbit: prep_stop(State)
    Rabbit->>Rabbit: 监督树停止子进程
    
    loop 每个队列
        Rabbit->>+Queue: terminate(shutdown, State)
        Queue->>Queue: 保存队列索引
        Queue->>Queue: 刷新消息到磁盘
        Queue->>Mnesia: 更新队列元数据<br/>（如消息数）
        Queue-->>-Rabbit: ok
    end
    
    Rabbit->>+Mnesia: mnesia:stop()
    Mnesia->>Mnesia: 保存表到磁盘
    Mnesia->>Mnesia: 关闭事务日志
    Mnesia-->>-Rabbit: ok
    
    Rabbit->>Rabbit: stop(State)
    Rabbit->>Rabbit: rabbit_boot_state:set(stopped)
    Rabbit-->>-CLI: ok
    
    Note over CLI,Mnesia: 重启
    CLI->>+Rabbit: start()
    Rabbit->>Rabbit: 预启动阶段
    Rabbit->>+Mnesia: mnesia:start()
    Mnesia->>Mnesia: 加载表（快速）
    Mnesia-->>-Rabbit: ok
    Rabbit->>Rabbit: Boot steps<br/>（跳过数据创建）
    Rabbit->>Queue: recover()
    Queue->>Queue: 加载队列索引<br/>（无需重建）
    Rabbit-->>-CLI: ok

# 启动（前台）
rabbitmq-server

# 启动（后台）
rabbitmq-server -detached

# 停止
rabbitmqctl stop

# 停止应用（保留 Erlang 节点）
rabbitmqctl stop_app

# 启动应用
rabbitmqctl start_app

# 等待启动完成
rabbitmqctl await_startup

# 检查状态
rabbitmqctl status

# 查看告警
rabbitmqctl alarm_list