stateDiagram-v2
    [*] --> Initializing: NewDaemon()
    Initializing --> LoadingConfig: 验证配置
    LoadingConfig --> ConnectingContainerd: 连接 containerd
    ConnectingContainerd --> InitPlugins: 初始化插件系统
    InitPlugins --> InitVolumes: 初始化卷服务
    InitVolumes --> LoadContainers: 加载已存在容器
    LoadContainers --> InitGraphDriver: 初始化存储驱动
    InitGraphDriver --> InitImageService: 初始化镜像服务
    InitImageService --> InitNetwork: 初始化网络控制器
    InitNetwork --> RestoreContainers: 恢复容器状态
    RestoreContainers --> Running: 守护进程就绪
    Running --> Reloading: 收到 SIGHUP
    Reloading --> Running: 热加载完成
    Running --> ShuttingDown: 收到 SIGTERM/SIGINT
    ShuttingDown --> CleaningUp: 停止所有容器
    CleaningUp --> [*]: Daemon 退出

flowchart TB
    subgraph DaemonCore["Daemon 核心"]
        Daemon[Daemon 实例]
        ConfigStore[配置存储<br/>atomic.Pointer]
        EventService[事件服务<br/>EventsService]
        ContainerStore[容器注册表<br/>container.Store]
        ExecStore[Exec 命令存储<br/>ExecStore]
    end
    
    subgraph Services["服务组件"]
        ImageSvc[镜像服务<br/>ImageService]
        VolumeSvc[卷服务<br/>VolumesService]
        PluginMgr[插件管理器<br/>PluginManager]
        NetworkCtrl[网络控制器<br/>libnetwork.Controller]
        RegistrySvc[注册表服务<br/>registry.Service]
    end
    
    subgraph Runtime["运行时层"]
        ContainerdClient[containerd 客户端]
        GraphDriver[存储驱动<br/>overlay2/aufs/...]
        LibcontainerdClient[libcontainerd 客户端]
    end
    
    subgraph Storage["持久化"]
        BoltDB[(BoltDB<br/>容器元数据)]
        FileSystem[(文件系统<br/>/var/lib/docker)]
    end
    
    Daemon --> ConfigStore
    Daemon --> EventService
    Daemon --> ContainerStore
    Daemon --> ExecStore
    
    Daemon --> ImageSvc
    Daemon --> VolumeSvc
    Daemon --> PluginMgr
    Daemon --> NetworkCtrl
    Daemon --> RegistrySvc
    
    ImageSvc --> ContainerdClient
    ImageSvc --> GraphDriver
    Daemon --> LibcontainerdClient
    LibcontainerdClient --> ContainerdClient
    
    ContainerStore --> BoltDB
    ImageSvc --> FileSystem
    VolumeSvc --> FileSystem

sequenceDiagram
    autonumber
    participant Main as cmd/dockerd/main
    participant Command as daemon/command
    participant Daemon as daemon.Daemon
    participant Containerd as containerd Client
    participant Plugin as PluginManager
    participant Volume as VolumeService
    participant Image as ImageService
    participant Network as libnetwork
    
    Main->>Command: NewDaemonRunner()
    Main->>Command: Run(ctx)
    
    Command->>Command: 解析配置文件 daemon.json
    Command->>Command: 创建监听器（Unix Socket/TCP）
    
    Note over Command: 初始化插件存储
    Command->>Plugin: NewStore(pluginsRoot)
    
    Note over Command: 初始化 Daemon
    Command->>Daemon: NewDaemon(config, pluginStore)
    
    Note over Daemon: 1. 平台检查
    Daemon->>Daemon: checkSystem()
    Daemon->>Daemon: verifyDaemonSettings()
    
    Note over Daemon: 2. 用户命名空间
    Daemon->>Daemon: setupRemappedRoot()
    
    Note over Daemon: 3. 连接 containerd
    Daemon->>Containerd: containerd.New(address)
    Containerd-->>Daemon: Client 实例
    
    Note over Daemon: 4. 初始化插件管理器
    Daemon->>Plugin: NewManager(config)
    Plugin->>Plugin: 扫描插件目录
    Plugin->>Plugin: 启动已启用插件
    Plugin-->>Daemon: PluginManager 实例
    
    Note over Daemon: 5. 初始化卷服务
    Daemon->>Volume: NewVolumeService(root, pluginStore)
    Volume->>Volume: 初始化 local 驱动
    Volume->>Volume: 加载卷元数据
    Volume-->>Daemon: VolumeService 实例
    
    Note over Daemon: 6. 容器存储初始化
    Daemon->>Daemon: container.NewMemoryStore()
    Daemon->>Daemon: container.NewViewDB()
    
    Note over Daemon: 7. 加载已存在容器
    Daemon->>Daemon: loadContainers(ctx)
    loop 遍历容器目录
        Daemon->>Daemon: 读取 config.v2.json
        Daemon->>Daemon: 解析容器配置
        Daemon->>Daemon: 注册到 ContainerStore
    end
    
    Note over Daemon: 8. 初始化存储驱动
    Daemon->>Daemon: graphdriver.New(driver, root)
    alt driver == overlay2
        Daemon->>Daemon: 检查内核支持
        Daemon->>Daemon: 挂载 overlay2
    else driver == aufs
        Daemon->>Daemon: 加载 aufs 模块
    end
    
    Note over Daemon: 9. 初始化镜像服务
    Daemon->>Image: NewImageService(config)
    Image->>Containerd: 连接镜像服务 API
    Image->>Image: 初始化 LayerStore
    Image->>Image: 初始化 ReferenceStore
    Image-->>Daemon: ImageService 实例
    
    Note over Daemon: 10. 初始化网络
    Daemon->>Network: libnetwork.New(config)
    Network->>Network: 创建默认网络（bridge）
    Network->>Network: 加载网络端点
    Network-->>Daemon: Controller 实例
    
    Note over Daemon: 11. 恢复容器状态
    Daemon->>Daemon: restoreContainers(ctx)
    loop 运行中的容器
        Daemon->>Containerd: Load(containerID)
        Containerd-->>Daemon: Task 句柄
        Daemon->>Daemon: 重新连接日志流
        Daemon->>Daemon: 重新连接网络
    end
    
    Daemon-->>Command: Daemon 实例
    
    Note over Command: 12. 启动 API 服务器
    Command->>Command: buildRouters(daemon)
    Command->>Command: CreateMux(routers)
    Command->>Command: httpServer.Serve(listener)
    
    Note over Command: 13. 启动集群（如果配置）
    Command->>Command: createAndStartCluster(daemon)
    
    Note over Command: 14. 启动 BuildKit
    Command->>Command: initBuildkit(daemon)
    
    Command-->>Main: 守护进程运行中

// 核心代码示例
d.containerdClient, err = containerd.New(
    cfgStore.ContainerdAddr, // 默认 /run/containerd/containerd.sock
    containerd.WithDefaultNamespace("moby"),
    containerd.WithTimeout(60 * time.Second),
)

d.pluginManager, err = plugin.NewManager(plugin.ManagerConfig{
    Root:               "/var/lib/docker/plugins",
    ExecRoot:           "/run/docker/plugins",
    Store:              d.PluginStore,
    CreateExecutor:     createPluginExec, // containerd 执行器
    RegistryService:    registryService,
    LiveRestoreEnabled: true,
})

d.volumes, err = volumesservice.NewVolumeService(
    cfgStore.Root,        // /var/lib/docker
    d.PluginStore,        // 插件卷驱动
    idtools.Identity{UID: uid, GID: gid}, // 用户映射
    d,                    // EventLogger 接口
)

d.containers = container.NewMemoryStore() // 内存索引
d.containersReplica, _ = container.NewViewDB() // BoltDB 视图

containers, err := d.loadContainers(ctx)
for _, c := range containers {
    // 读取 /var/lib/docker/containers/<id>/config.v2.json
    // 解析容器配置
    // 注册到 ContainerStore
}

driverName := os.Getenv("DOCKER_DRIVER") // 或 daemon.json 配置
graphDriver, err := graphdriver.New(
    driverName,          // overlay2/aufs/devicemapper
    cfgStore.Root,       // /var/lib/docker
    graphdriver.Options{
        DriverOptions: cfgStore.GraphOptions,
        UIDMaps:       idMapping.UIDs(),
        GIDMaps:       idMapping.GIDs(),
    },
)

d.imageService, err = images.NewImageService(images.ImageServiceConfig{
    ContainerdClient:  d.containerdClient,
    LayerStore:        layerStore, // 存储驱动封装
    ReferenceStore:    refStore,   // 镜像引用（tag -> digest）
    RegistryService:   d.registryService,
    EventsService:     d.EventsService,
    ...
})

controller, err := libnetwork.New(libnetwork.OptionDataDir(
    filepath.Join(cfgStore.Root, "network"),
))
// 创建默认 bridge 网络
if !cfgStore.DisableBridge {
    controller.NewNetwork("bridge", "bridge", networkOptions...)
}

func (daemon *Daemon) restoreContainers(ctx context.Context) {
    for _, c := range daemon.containers.List() {
        if c.IsRunning() {
            // 重新连接到 containerd Task
            task, err := daemon.containerd.LoadContainer(ctx, c.ID)
            // 重新连接日志流
            daemon.attachContainerStreams(c)
            // 重新连接网络
            daemon.connectToNetwork(c)
        }
    }
}

func (daemon *Daemon) containerStart(ctx context.Context, container *container.Container) error {
    container.Lock()
    defer container.Unlock()
    
    // 检查状态
    if container.Running {
        return nil // 幂等：已启动返回成功
    }
    if container.RemovalInProgress {
        return errdefs.Conflict("container is being removed")
    }
    
    // 启动逻辑...
}

func (daemon *Daemon) Reload(conf *config.Config) error {
    daemon.configReload.Lock()
    defer daemon.configReload.Unlock()
    
    // 验证新配置
    if err := validateReloadableConfig(conf); err != nil {
        return err
    }
    
    // 原子替换配置指针
    newStore := &configStore{Config: *conf}
    daemon.configStore.Store(newStore)
    
    // 应用新配置到子系统
    daemon.reloadLogConfig(conf)
    daemon.reloadLabels(conf)
    
    return nil
}

// 监听 containerd 事件流
go func() {
    for {
        events, errs := d.containerd.Subscribe(ctx, filters...)
        select {
        case err := <-errs:
            log.Errorf("containerd connection lost: %v", err)
            // 指数退避重连
            backoff.Retry(func() error {
                return d.reconnectContainerd()
            })
        case evt := <-events:
            d.processContainerdEvent(evt)
        }
    }
}()

// 内存索引 + 前缀匹配
type Store struct {
    byID   map[string]*Container
    byName map[string]*Container
}

func (s *Store) Get(nameOrID string) *Container {
    // 精确匹配优先（O(1)）
    if c := s.byID[nameOrID]; c != nil {
        return c
    }
    if c := s.byName[nameOrID]; c != nil {
        return c
    }
    
    // 前缀匹配（O(n)）
    for id, c := range s.byID {
        if strings.HasPrefix(id, nameOrID) {
            return c
        }
    }
    return nil
}

// 使用带缓冲 channel 避免阻塞
type Events struct {
    subscribers map[string]chan *Event
    buffer      int // 默认 100
}

func (e *Events) Publish(evt *Event) {
    for _, ch := range e.subscribers {
        select {
        case ch <- evt:
        default:
            // 满则丢弃旧事件
            <-ch
            ch <- evt
        }
    }
}

// 使用 atomic.Pointer 避免锁
type Daemon struct {
    configStore atomic.Pointer[configStore]
}

func (d *Daemon) config() *configStore {
    return d.configStore.Load() // 无锁读取
}

# Daemon 状态
engine_daemon_info{version="24.0.0", os="linux", arch="amd64"}

# 容器操作
engine_daemon_container_actions_seconds{action="create"} histogram
engine_daemon_container_actions_seconds{action="start"} histogram
engine_daemon_container_states_containers{state="running"} gauge
engine_daemon_container_states_containers{state="paused"} gauge
engine_daemon_container_states_containers{state="stopped"} gauge

# 镜像操作
engine_daemon_image_actions_seconds{action="pull"} histogram
engine_daemon_image_actions_seconds{action="push"} histogram

# 网络操作
engine_daemon_network_actions_seconds{action="create"} histogram
engine_daemon_network_actions_seconds{action="connect"} histogram

# 健康状态
engine_daemon_health_checks_failed_total counter

# 实时监听所有事件
curl --unix-socket /var/run/docker.sock \
  http://localhost/events

# 过滤容器事件
curl --unix-socket /var/run/docker.sock \
  'http://localhost/events?filters={"type":["container"]}'

# 示例事件
{
  "status": "start",
  "id": "abc123...",
  "from": "nginx:latest",
  "Type": "container",
  "Action": "start",
  "Actor": {
    "ID": "abc123...",
    "Attributes": {
      "image": "nginx:latest",
      "name": "web"
    }
  },
  "time": 1678886400,
  "timeNano": 1678886400000000000
}

{
  "data-root": "/data/docker",
  "storage-driver": "overlay2",
  "storage-opts": [
    "overlay2.override_kernel_check=true"
  ],
  "log-driver": "json-file",
  "log-opts": {
    "max-size": "100m",
    "max-file": "3",
    "compress": "true"
  },
  "live-restore": true,
  "userland-proxy": false,
  "icc": false,
  "default-ulimits": {
    "nofile": {
      "Name": "nofile",
      "Hard": 64000,
      "Soft": 64000
    }
  },
  "max-concurrent-downloads": 10,
  "max-concurrent-uploads": 10,
  "shutdown-timeout": 60,
  "debug": false,
  "experimental": false
}

groups:

  - name: docker_daemon
    rules:
      - alert: DaemonContainerCreateSlow
        expr: histogram_quantile(0.95, engine_daemon_container_actions_seconds{action="create"}) > 5
        for: 5m
        annotations:
          summary: "容器创建 P95 延迟超过 5 秒"
      
      - alert: DaemonImagePullFailed
        expr: rate(engine_daemon_image_actions_seconds_count{action="pull",error="true"}[5m]) > 0.1
        for: 5m
        annotations:
          summary: "镜像拉取失败率超过 10%"
      
      - alert: DaemonHighMemory
        expr: process_resident_memory_bytes{job="docker"} > 2e9
        for: 10m
        annotations:
          summary: "Daemon 内存占用超过 2GB"

# 检查 systemd 日志
journalctl -u docker -n 100 --no-pager

# 检查配置文件语法
dockerd --validate --config-file=/etc/docker/daemon.json

# 手动启动获取详细日志
dockerd --debug --log-level=debug

# 检查 containerd 状态
systemctl status containerd

# 查看 containerd 日志
journalctl -u containerd -f

# 检查存储驱动
docker info | grep -i storage

# 查看慢操作
docker events --filter 'type=container' --format '{{.TimeNano}} {{.Status}}' \
  | awk '{print ($1 - prev), $2; prev=$1}'

# 分析 CPU 占用
perf top -p $(pidof dockerd)

# 查看 goroutine 泄漏
kill -USR1 $(pidof dockerd)  # 生成 goroutine dump
ls -lh /var/run/docker/goroutine-*.dump

// GET /info    httputils.WriteJSON(w, http.StatusOK, info)
// 版本过滤示例（<1.44）：
// if versions.LessThan(version, "1.44") { info.ContainerDSecriptor = nil }

// GET /version
v := &types.Version{
    Platform: struct{ Name string }{dockerversion.PlatformName},
    Version: dockerversion.Version,
    APIVersion: dockerversion.DefaultAPIVersion,
    MinAPIVersion: dockerversion.MinAPIVersion,
    GitCommit: dockerversion.GitCommit,
    BuildTime: dockerversion.BuildTime,
    GoVersion: runtime.Version(),
    Os: runtime.GOOS,
    Arch: runtime.GOARCH,
}

func (s *systemRouter) pingHandler(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    // 1. 设置缓存控制头
    w.Header().Add("Cache-Control", "no-cache, no-store, must-revalidate")
    w.Header().Add("Pragma", "no-cache")
    
    // 2. 设置构建器版本
    builderVersion := build.BuilderVersion(s.features())
    w.Header().Set("Builder-Version", string(builderVersion))
    
    // 3. 设置 Swarm 状态
    w.Header().Set("Swarm", s.swarmStatus())
    
    // 4. HEAD 请求仅返回头
    if r.Method == http.MethodHead {
        w.Header().Set("Content-Type", "text/plain; charset=utf-8")
        w.Header().Set("Content-Length", "0")
        return nil
    }
    
    // 5. GET 请求返回 "OK"
    _, err := w.Write([]byte{'O', 'K'})
    return err
}

#!/bin/bash
# Docker健康检查
if curl -f -s http://localhost:2375/_ping > /dev/null; then
    echo "Docker is healthy"
    exit 0
else
    echo "Docker is unhealthy"
    exit 1
fi

services:
  app:
    image: myapp
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:2375/_ping"]
      interval: 30s
      timeout: 10s
      retries: 3

type Info struct {
    // 守护进程信息
    ID                string // 守护进程唯一 ID
    Name              string // 主机名
    ServerVersion     string // Docker 版本
    OperatingSystem   string // 操作系统
    OSType            string // OS 类型（linux/windows）
    Architecture      string // CPU 架构
    KernelVersion     string // 内核版本
    
    // 容器信息
    Containers        int // 总容器数
    ContainersRunning int // 运行中容器数
    ContainersPaused  int // 暂停的容器数
    ContainersStopped int // 停止的容器数
    
    // 镜像信息
    Images            int // 镜像数量
    
    // 驱动信息
    Driver            string              // 存储驱动
    DriverStatus      [][2]string         // 驱动状态
    Plugins           PluginsInfo         // 插件信息
    
    // 资源限制
    MemTotal          int64  // 总内存（字节）
    NCPU              int    // CPU 数量
    
    // 网络
    IndexServerAddress string // 注册表服务器地址
    
    // Swarm 信息
    Swarm              swarm.Info
    
    // 运行时
    Runtimes          map[string]Runtime
    DefaultRuntime    string
    
    // 警告
    Warnings          []string
}

func (s *systemRouter) getInfo(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    version := httputils.VersionFromContext(ctx)
    
    // 使用单飞模式防止并发调用
    info, _, _ := s.collectSystemInfo.Do(ctx, version, func(ctx context.Context) (*infoResponse, error) {
        // 1. 获取基础信息
        info, err := s.backend.SystemInfo(ctx)
        
        // 2. 添加 Swarm 信息
        if s.cluster != nil {
            info.Swarm = s.cluster.Info(ctx)
            info.Warnings = append(info.Warnings, info.Swarm.Warnings...)
        }
        
        // 3. API 版本兼容性处理
        if versions.LessThan(version, "1.44") {
            // 移除 v1.44 引入的字段
        }
        
        return &infoResponse{Info: info}, nil
    })
    
    return httputils.WriteJSON(w, http.StatusOK, info)
}

func (daemon *Daemon) SystemInfo(ctx context.Context) (*system.Info, error) {
    // 1. 收集容器信息
    containers := daemon.containers.List()
    var running, paused, stopped int
    for _, c := range containers {
        switch c.State.StateString() {
        case "running":
            running++
        case "paused":
            paused++
        default:
            stopped++
        }
    }
    
    // 2. 收集镜像信息
    images, _ := daemon.imageService.Images(ctx)
    
    // 3. 收集系统资源
    memInfo, _ := meminfo.Read()
    
    // 4. 组装响应
    return &system.Info{
        ID:                daemon.id,
        Containers:        len(containers),
        ContainersRunning: running,
        ContainersPaused:  paused,
        ContainersStopped: stopped,
        Images:            len(images),
        Driver:            daemon.imageService.StorageDriver(),
        MemTotal:          memInfo.MemTotal,
        NCPU:              runtime.NumCPU(),
        OperatingSystem:   platform.GetOperatingSystem(),
        OSType:            runtime.GOOS,
        Architecture:      platform.Architecture,
        KernelVersion:     platform.GetKernelVersion(),
        ServerVersion:     dockerversion.Version,
        Runtimes:          daemon.runtimes,
        DefaultRuntime:    daemon.defaultRuntime,
    }, nil
}

type Version struct {
    Version       string // Docker 版本（例如："24.0.7"）
    ApiVersion    string // API 版本（例如："1.43"）
    MinAPIVersion string // 最小 API 版本
    GitCommit     string // Git commit ID
    GoVersion     string // Go 版本
    Os            string // 操作系统
    Arch          string // 架构
    KernelVersion string // 内核版本
    BuildTime     string // 构建时间
    
    // 组件版本
    Components []ComponentVersion
}

type ComponentVersion struct {
    Name    string // 组件名称（Engine/containerd/runc/docker-init）
    Version string // 版本号
    Details map[string]string // 详细信息
}

func (s *systemRouter) getVersion(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    info, err := s.backend.SystemVersion(ctx)
    return httputils.WriteJSON(w, http.StatusOK, info)
}

type Message struct {
    Type   string // 事件类型
    Action string // 动作（create/start/stop/die）
    Actor  Actor  // 事件主体
    Time   int64  // 时间戳
    TimeNano int64 // 纳秒时间戳
}

type Actor struct {
    ID         string            // 对象 ID
    Attributes map[string]string // 属性
}

func (s *systemRouter) getEvents(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    // 1. 解析参数
    since, _ := strconv.ParseInt(r.Form.Get("since"), 10, 64)
    until, _ := strconv.ParseInt(r.Form.Get("until"), 10, 64)
    filters, _ := filters.FromJSON(r.Form.Get("filters"))
    
    // 2. 订阅事件
    eventCh := s.backend.SubscribeToEvents(since, until, filters)
    defer s.backend.UnsubscribeFromEvents(eventCh)
    
    // 3. 流式输出
    w.Header().Set("Content-Type", "application/json")
    enc := json.NewEncoder(w)
    
    for {
        select {
        case event := <-eventCh:
            if err := enc.Encode(event); err != nil {
                return err
            }
            w.(http.Flusher).Flush()
        case <-ctx.Done():
            return nil
        }
    }
}

type DiskUsage struct {
    LayersSize  int64                    // 镜像层总大小
    Images      []*ImageSummary          // 镜像列表
    Containers  []*Container             // 容器列表
    Volumes     []*Volume                // 卷列表
    BuildCache  []*BuildCacheDiskUsage   // 构建缓存
}

func (s *systemRouter) getDiskUsage(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    // 1. 解析类型参数
    var getContainers, getImages, getVolumes, getBuildCache bool
    typeStrs := r.Form["type"]
    
    // 2. 并发收集各类资源
    var eg errgroup.Group
    var usage backend.DiskUsage
    
    if getImages {
        eg.Go(func() error {
            usage.Images, _ = s.backend.ImageDiskUsage(ctx)
            return nil
        })
    }
    
    if getContainers {
        eg.Go(func() error {
            usage.Containers, _ = s.backend.ContainerDiskUsage(ctx)
            return nil
        })
    }
    
    if getVolumes {
        eg.Go(func() error {
            usage.Volumes, _ = s.backend.VolumesDiskUsage(ctx)
            return nil
        })
    }
    
    if getBuildCache {
        eg.Go(func() error {
            usage.BuildCache, _ = s.builder.DiskUsage(ctx)
            return nil
        })
    }
    
    eg.Wait()
    
    return httputils.WriteJSON(w, http.StatusOK, usage)
}

type AuthConfig struct {
    Username      string // 用户名
    Password      string // 密码
    Auth          string // Base64 编码的 username:password
    Email         string // 邮箱（已废弃）
    ServerAddress string // 注册表服务器地址
    IdentityToken string // 身份令牌
    RegistryToken string // 注册表令牌
}

type AuthenticateOKBody struct {
    Status        string // 认证状态
    IdentityToken string // 身份令牌
}

func (s *systemRouter) postAuth(ctx context.Context, w http.ResponseWriter, r *http.Request, vars map[string]string) error {
    // 1. 解析认证配置
    var authConfig registry.AuthConfig
    if err := json.NewDecoder(r.Body).Decode(&authConfig); err != nil {
        return err
    }
    
    // 2. 验证凭据
    status, token, err := s.backend.AuthenticateToRegistry(ctx, &authConfig)
    if err != nil {
        return err
    }
    
    // 3. 返回结果
    return httputils.WriteJSON(w, http.StatusOK, registry.AuthenticateOKBody{
        Status:        status,
        IdentityToken: token,
    })
}

classDiagram
    class Daemon {
        -string id
        -string repository
        -container.Store containers
        -*container.ViewDB containersReplica
        -*container.ExecStore execCommands
        -ImageService imageService
        -*atomic.Pointer~configStore~ configStore
        -*events.Events EventsService
        -*libnetwork.Controller netController
        -*volumesservice.VolumesService volumes
        -string root
        -*plugin.Manager pluginManager
        -*containerd.Client containerdClient
        -user.IdentityMapping idMapping
        -[]byte seccompProfile
        -uint64 machineMemory
        +Shutdown() error
        +Reload(config) error
    }
    
    class Config {
        +string Root
        +bool Debug
        +[]string Hosts
        +map~string,bool~ Features
        +string DefaultRuntime
        +map~string,RuntimeConfig~ Runtimes
        +NetworkConfig NetworkConfig
        +LogConfig LogConfig
        +int MaxConcurrentDownloads
        +int MaxConcurrentUploads
        +bool LiveRestoreEnabled
    }
    
    class Info {
        +string ID
        +int Containers
        +int ContainersRunning
        +int ContainersPaused
        +int ContainersStopped
        +int Images
        +string Driver
        +int64 MemTotal
        +int NCPU
        +string OperatingSystem
        +string OSType
        +string Architecture
        +string KernelVersion
        +string ServerVersion
        +map~string,Runtime~ Runtimes
        +string DefaultRuntime
        +swarm.Info Swarm
        +[]string Warnings
    }
    
    class EventsService {
        +Subscribe() chan Message
        +Unsubscribe(chan)
        +Publish(Message)
    }
    
    class Message {
        +string Type
        +string Action
        +Actor Actor
        +int64 Time
        +int64 TimeNano
    }
    
    Daemon "1" *-- "1" Config : uses
    Daemon "1" *-- "1" EventsService : manages
    EventsService "1" --> "*" Message : publishes

type Daemon struct {
    // 标识
    id         string // 守护进程唯一 ID
    repository string // 存储仓库路径
    
    // 容器管理
    containers        container.Store      // 容器存储
    containersReplica *container.ViewDB    // 容器视图数据库
    execCommands      *container.ExecStore // Exec 命令存储
    
    // 镜像管理
    imageService ImageService // 镜像服务
    
    // 配置
    configStore  atomic.Pointer[configStore] // 配置存储（支持热重载）
    configReload sync.Mutex                  // 配置重载锁
    
    // 事件服务
    EventsService *events.Events // 事件发布/订阅
    
    // 网络管理
    netController *libnetwork.Controller // 网络控制器
    
    // 卷管理
    volumes *volumesservice.VolumesService // 卷服务
    
    // 存储
    root     string    // 根目录（/var/lib/docker）
    sysInfo  *sysinfo.SysInfo // 系统信息缓存
    
    // 插件
    pluginManager *plugin.Manager // 插件管理器
    
    // 容器运行时
    containerdClient *containerd.Client     // containerd 客户端
    containerd       libcontainerdtypes.Client // containerd 接口
    
    // 安全
    idMapping      user.IdentityMapping // 用户命名空间映射
    seccompProfile []byte                // Seccomp 配置
    
    // 资源
    machineMemory uint64 // 机器总内存
    
    // 状态
    shutdown   bool          // 是否正在关闭
    startupDone chan struct{} // 启动完成信号
}