ardb 启动流程图

@startuml
activate main
main -> Ardb: Ardb()
activate Ardb
main <-- Ardb: Ardb()
deactivate Ardb

main -> Ardb: init()
activate Ardb

Ardb -> Engine: create_engine()
activate Engine
Ardb <-- Engine: create_engine()
deactivate Engine

Ardb -> Engine: Init()
activate Engine
Ardb <-- Engine: Init()
deactivate Engine

main <-- Ardb: init()
deactivate Ardb

main -> Server: Start()

activate Server
Server -> ReplicationService: Init()

activate ReplicationService
ReplicationService -> SnapshotManager: Init()
activate SnapshotManager

SnapshotManager -> SnapshotManager: AddSnapshot()
activate SnapshotManager
deactivate SnapshotManager

ReplicationService <-- SnapshotManager: Init()
deactivate SnapshotManager

ReplicationService -> ReplicationBacklog: Init()
activate ReplicationBacklog
ReplicationService <-- ReplicationBacklog: Init()
deactivate ReplicationBacklog

ReplicationService -> Master: Init()
activate Master
ReplicationService <-- Master: Init()
deactivate Master

ReplicationService -> Slave: Init()
activate Slave
Slave -> DBWriter: Init()
activate DBWriter

loop GetConf().thread_pool_size
DBWriter -> DBWriterWorker: DBWriterWorker()
activate DBWriterWorker
DBWriter <-- DBWriterWorker: DBWriterWorker()
deactivate DBWriterWorker

DBWriter -> DBWriterWorker: Start()
activate DBWriterWorker
DBWriter <-- DBWriterWorker: Start()
deactivate DBWriterWorker
end

Slave <-- DBWriter: Init()
deactivate DBWriter
ReplicationService <-- Slave: Init()
deactivate Slave

Server <-- ReplicationService: Init()
deactivate ReplicationService

Server -> ChannelService: ChannelService()
activate ChannelService
ChannelService -> EventLoop:aeCreateEventLoop()
activate EventLoop
ChannelService <-- EventLoop:aeCreateEventLoop()
deactivate EventLoop

ChannelService -> SoftSignalChannel:NewSoftSignalChannel()
activate SoftSignalChannel

SoftSignalChannel -> SoftSignalChannel:SoftSignalChannel()
activate SoftSignalChannel

deactivate SoftSignalChannel

SoftSignalChannel -> PipeChannel: Open()
activate PipeChannel
PipeChannel -> PipeChannel: DoOpen()
activate PipeChannel

PipeChannel -> EventLoop: aeCreateFileEvent()
activate EventLoop
PipeChannel <-- EventLoop: aeCreateFileEvent()
deactivate EventLoop

SoftSignalChannel <-- PipeChannel: Open()
deactivate PipeChannel
deactivate PipeChannel

ChannelService <-- SoftSignalChannel:NewSoftSignalChannel()
deactivate SoftSignalChannel

ChannelService -> SoftSignalChannel:Register()
activate SoftSignalChannel
ChannelService <-- SoftSignalChannel:Register()
deactivate SoftSignalChannel

Server <-- ChannelService: ChannelService()
deactivate ChannelService

Server -> ChannelService: SetThreadPoolSize()
activate ChannelService
Server <-- ChannelService: SetThreadPoolSize()
deactivate ChannelService

Server -> ChannelService: RegisterLifecycleCallback()
activate ChannelService
Server <-- ChannelService: RegisterLifecycleCallback()
deactivate ChannelService

loop GetConf().servers.size() times
    Server -> ServerSocketChannel: Bind()
    activate ServerSocketChannel
    ServerSocketChannel -> ServerSocketChannel: DoBind()
    activate ServerSocketChannel
    ServerSocketChannel -> EventLoop:aeCreateFileEvent()
    activate EventLoop
    ServerSocketChannel <-- EventLoop:aeCreateFileEvent()
    deactivate EventLoop
    deactivate ServerSocketChannel
    Server <-- ServerSocketChannel: Bind()
    deactivate ServerSocketChannel

    Server -> ServerSocketChannel: SetChannelPipelineInitializor()
    note right: set pipeline\n  RedisCommandDecoder\n  RedisReplyEncoder\n  RedisRequestHandler
    activate ServerSocketChannel
    Server <-- ServerSocketChannel: SetChannelPipelineInitializor()
    deactivate ServerSocketChannel

    'Server -> ServerSocketChannel: SetChannelPipelineFinalizer()
    'activate ServerSocketChannel
    'Server <-- ServerSocketChannel: SetChannelPipelineFinalizer()
    'deactivate ServerSocketChannel

    Server -> ServerSocketChannel: BindThreadPool()
    activate ServerSocketChannel
    Server <-- ServerSocketChannel: BindThreadPool()
    deactivate ServerSocketChannel
end

Server -> Server: StartCrons()

Server -> ChannelService: Start()
activate ChannelService
ChannelService -> ChannelService: StartSubPool()
activate ChannelService
deactivate ChannelService

ChannelService -> EventLoop: aeMain()
activate EventLoop

loop !eventLoop->stop
    EventLoop -> EventLoop: aeProcessEvents()
end

ChannelService <-- EventLoop: aeMain()
deactivate EventLoop

Server <-- ChannelService: Start()
deactivate ChannelService

main <-- Server: Start()

deactivate Server
deactivate main

@enduml

• ardb github