《容器技术系列》一3.3 mainDaemon()的具体实现-阿里云开发者社区

开发者社区> 华章出版社> 正文

《容器技术系列》一3.3 mainDaemon()的具体实现

简介:

本节书摘来异步社区《容器技术系列》一书中的第3章 ,第3.3节,孙宏亮 著, 更多章节内容可以访问云栖社区“异步社区”公众号查看。

3.3 mainDaemon()的具体实现

Docker Daemon的启动流程图展示了DockerDaemon的从无到有。通过分析流程图,我们可以得出一个这样的结论:区分Docker Daemon与Docker Client的关键在于flag参数flDaemon的值。一旦*flDaemon的值为真,则代表docker二进制需要启动的是Docker Daemon。有关Docker Daemon的所有的工作,都被包含在函数mainDaemon()的具体实现中。
宏观来讲,mainDaemon()的使命是:创建一个守护进程,并保证其正常运行。
从功能的角度来说,mainDaemon()实现了两部分内容:第一,创建Docker运行环境;第二,服务于Docker Client,接收并处理相应请求(完成Docker Server的初始化)。
从实现细节来分析,mainDaemon()的实现流程主要包含以下步骤:
1)daemon的配置初始化。这部分在init()函数中实现,即在mainDaemon()运行前就执行,但由于这部分内容和mainDaemon()的运行息息相关,可以认为是mainDaemon()运行的先决条件。
2)命令行flag参数检查。
3)创建engine对象。
4)设置engine的信号捕获及处理方法。
5)加载builtins。
6)使用goroutine加载daemon对象并运行。
7)打印Docker版本及驱动信息。
8)serveapi的创建与运行。
对于以上内容,本章将一一深入分析。

3.3.1 配置初始化

mainDaemon()的运行位于./docker/docker/docker/daemon.go,深入分析mainDaemon()的实现之前,我们回到Go 语言的特性,即变量与init函数的执行顺序。在daemon.go中,Docker定义了变量daemonCfg,以及init函数,通过Go 语言的特性,变量的定义与init函数均会在mainDaemon()之前运行。两者的定义如下:

var (
     daemonCfg = &daemon.Config{}
)
func init() {
     daemonCfg.InstallFlags()
}
首先,Docker声明一个名为daemonCfg的变量,代表整个Docker Daemon的配置信息。定义完毕之后,init函数的存在,使得daemonCfg变量能获取相应的属性值。在Docker Daemon启动时,daemonCfg变量被传递至Docker Daemon并被使用。
Config对象的定义如下(含部分属性的解释),该对象位于./docker/docker/daemon/config.go:
type Config struct {
     Pidfile                      string  //Docker Daemon所属进程的PID文件
     Root                        string  //Docker运行时所使用的root路径
     AutoRestart                 bool    //是否一直支持创建容器的重启
     Dns                         []string//DockerDaemon为容器准备的DNS Server地址
     DnsSearch                   []string//Docker使用的指定的DNS查找地址
     Mirrors                     []string//指定的Docker Registry镜像地址
     EnableIptables              bool    //是否启用Docker的iptables功能
     EnableIpForward             bool    //是否启用net.ipv4.ip_forward功能
     EnableIpMasq                bool    //启用IP伪装技术
     DefaultIp                   net.IP  //绑定容器端口时使用的默认IP
     BridgeIface                 string  //添加容器网络至已有的网桥接口名
     BridgeIP                    string  //创建网桥的IP地址
     FixedCIDR                   string  //指定IP的IPv4子网,必须被网桥子网包含
     InterContainerCommunication bool    //是否允许宿主机上Docker容器间的通信
     GraphDriver                 string  //Docker Daemon运行时使用的特定存储驱动
     GraphOptions                []string//可设置的存储驱动选项
     ExecDriver                  string  //Docker运行时使用的特定exec驱动
     Mtu                         int     //设置容器网络接口的MTU
     DisableNetwork              bool    //是否支持Docker容器的网络模式
     EnableSelinuxSupport        bool    //是否启用对SELinux功能的支持
     Context                     map[string][]string
}
Docker声明daemonCfg之后,init函数实现了daemonCfg变量中各属性的赋值,具体的实现为:daemonCfg.InstallFlags(),位于./docker/docker/daemon/config.go,代码如下:
func (config *Config) InstallFlags() {
         flag.StringVar(&config.Pidfile, []string{"p", "-pidfile"}, "/var/run/docker.pid", "Path to use for daemon PID file")
         flag.StringVar(&config.Root, []string{"g", "-graph"}, "/var/lib/docker", "Path to use as the root of the Docker runtime")
         flag.BoolVar(&config.AutoRestart, []string{"#r", "#-restart"}, true, "--restart on the daemon has been deprecated infavor of --restart policies on docker run")
         flag.BoolVar(&config.EnableIptables, []string{"#iptables", "-iptables"}, true, "Enable Docker's addition of iptables rules")
         flag.BoolVar(&config.EnableIpForward, []string{"#ip-forward", "-ip-forward"}, true, "Enable net.ipv4.ip_forward")
         flag.StringVar(&config.BridgeIP, []string{"#bip", "-bip"}, "", "Use this CIDR notation address for the network bridge's IP, not compatible with -b")
         flag.StringVar(&config.BridgeIface, []string{"b", "-bridge"}, "", "Attach containers to a pre-existing network bridge\nuse 'none' to disable container networking")
         flag.BoolVar(&config.InterContainerCommunication, []string{"#icc", "-icc"}, true, "Enable inter-container communication")
         flag.StringVar(&config.GraphDriver, []string{"s", "-storage-driver"}, "", "Force the Docker runtime to use a specific storage driver")
         flag.StringVar(&config.ExecDriver, []string{"e", "-exec-driver"}, "native", "Force the Docker runtime to use a specific exec driver")
         flag.BoolVar(&config.EnableSelinuxSupport, []string{"-selinux-enabled"}, false, "Enable selinux support. SELinux does not presently support the BTRFS storage driver")
         flag.IntVar(&config.Mtu, []string{"#mtu", "-mtu"}, 0, "Set the containers network MTU\nif no value is provided: default to the default route MTU or 1500 if no default route is available")
         opts.IPVar(&config.DefaultIp, []string{"#ip", "-ip"}, "0.0.0.0", "Default IP address to use when binding container ports")
         opts.ListVar(&config.GraphOptions, []string{"-storage-opt"}, "Set storage driver options")
     // FIXME: why the inconsistency between "hosts" and "sockets"?
         opts.IPListVar(&config.Dns, []string{"#dns", "-dns"}, "Force Docker to use specific DNS servers")
         opts.DnsSearchListVar(&config.DnsSearch, []string{"-dns-search"}, "Force Docker to use specific DNS search domains")
}

在函数InstallFlags()的实现过程中,Docker主要定义了众多类型不一的flag参数,并将该参数的值绑定在daemonCfg变量的指定属性上,如:

flag.StringVar(&config.Pidfile, []string{"p", "-pidfile"}, "/var/run/docker.pid", "Path to use for daemon PID file")

以上语句的含义为:
定义一个String类型的flag参数。
该flag的名称为"p"或者"-pidfile"。
该flag的默认值为"/var/run/docker.pid",并将该值绑定在变量config.Pidfile上。
该flag的描述信息为"Path to use for daemon PID file"。
至此,关于Docker Daemon所需要的配置信息均声明并初始化完毕。

3.3.2 flag参数检查

从本小节开始,程序运行真正进入Docker Daemon的mainDaemon(),下面对此流程进行深入分析。
mainDaemon()运行的第一个步骤是命令行flag参数的检查。具体而言,即当docker命令经过flag参数解析之后,Docker判断剩余的参数是否为0。若为0,则说明Docker Daemon的启动命令无误,正常运行;若不为0,则说明在启动Docker Daemon的时候,传入了多余的参数,此时Docker会输出错误提示,并退出运行程序。具体代码如下:

if flag.NArg() != 0 {
  flag.Usage()
  return
}

3.3.3 创建engine对象

在mainDaemon()运行过程中,flag参数检查完毕之后,Docker随即创建engine对象,代码如下:

eng := engine.New()

Engine是Docker架构中的运行引擎,同时也是Docker运行的核心模块。Engine扮演着Docker Container存储仓库的角色,并且通过Job的形式管理Docker运行中涉及的所有任务。
Engine结构体的定义位于./docker/docker/engine/engine.go#L47-L60,具体代码如下:

type Engine struct {
     handlers   map[string]Handler
     catchall   Handler
     hack       Hack // data for temporary hackery (see hack.go)
     id         string
     Stdout     io.Writer
     Stderr     io.Writer
     Stdin      io.Reader
     Logging    bool
     tasks      sync.WaitGroup
     l          sync.RWMutex // lock for shutdown
     shutdown   bool
     onShutdown []func() // shutdown handlers
}

Engine结构体中最为重要的是handlers属性,handlers属性为map类型,key的类型是string,value的类型是Handler。其中Handler类型的定义位于./docker/docker/engine/engine.go#L23,具体代码如下:
type Handler func(*Job) Status
可见,Handler为一个定义的函数。该函数传入的参数为Job指针,返回为Status状态。
了解完Engine以及Handler的基本知识之后,我们真正进入创建Engine实例的部分,即New()函数的实现,具体代码如下:

func New() *Engine {
     eng := &Engine{
          handlers: make(map[string]Handler),
          id:       utils.RandomString(),
          Stdout:   os.Stdout,
          Stderr:   os.Stderr,
          Stdin:    os.Stdin,
          Logging:  true,
     }
     eng.Register("commands", func(job *Job) Status {
          for _, name := range eng.commands() {
               job.Printf("%s\n", name)
          }
          return StatusOK
     })
     // Copy existing global handlers
     for k, v := range globalHandlers {
          eng.handlers[k] = v
     }
     return eng
}

分析以上代码,从返回结果可以发现,New()函数最终返回一个Engine实例对象。而在代码实现部分,大致可以将其分为三个步骤:
1)创建一个Engine结构体实例eng,并初始化部分属性,如handlers、id、标准输出stdout、日志属性Logging等。
2)向eng对象注册名为commands的Handler,其中Handler为临时定义的函数func(job *Job) Status{ },该函数的作用是通过Job来打印所有已经注册完毕的command名称,最终返回状态StatusOK。
3)将变量globalHandlers中定义完毕的所有Handler都复制到eng对象的handlers属性中。
至此,一个基本的Engine对象实例eng已经创建完毕,并实现部分属性的初始化。Docker Daemon启动的后续过程中,仍然会对Engine对象实例进行额外的配置。

3.3.4 设置engine的信号捕获

Docker在包engine中执行完Engine对象的创建与初始化之后,回到mainDaemon()函数的运行,紧接着执行的代码为:
signal.Trap(eng.Shutdown)
Docker Daemon作为Linux操作系统上的一个后台进程,原则上应该具备处理信号的能力。信号处理能力的存在,能保障Docker管理员可以通过向Docker Daemon发送信号的方式,管理Docker Daemon的运行。
再来看以上代码则不难理解其中的含义:在Docker Daemon的运行中,设置捕获特定信号后的处理方法,特定信号有SIGINT、SIGTERM以及SIGQUIT;当程序捕获SIGINT或者SIGTERM信号时,执行相应的善后操作,最后保证Docker Daemon程序退出。
该部分代码的实现位于./docker/docker/pkg/signal/trap.go。实现的流程分为以下4个步骤:
1)创建并设置一个channel,用于发送信号通知。
2)定义signals数组变量,初始值为os.SIGINT, os.SIGTERM;若环境变量DEBUG为空,则添加os.SIGQUIT至signals数组。
3)通过gosignal.Notify(c, signals...)中Notify函数来实现将接收到的signal信号传递给c。需要注意的是只有signals中被罗列出的信号才会被传递给c,其余信号会被直接忽略。
4)创建一个goroutine来处理具体的signal信号,当信号类型为os.Interrupt或者syscall.SIGTERM时,执行传入Trap函数的具体执行方法,形参为cleanup(),实参为eng.Shutdown。
Shutdown()函数的定义位于./docker/docker/engine/engine.go#L153-L199,主要完成的任务是:Docker Daemon关闭时,做一些必要的善后工作。
善后工作主要有以下4项:

Docker Daemon不再接受任何新的Job。
Docker Daemon等待所有存活的Job执行完毕。
Docker Daemon调用所有shutdown的处理方法。

在15秒时间内,若所有的handler执行完毕,则 Shutdown()函数返回,否则强制返回。
由于在signal.Trap( eng.Shutdown )函数的具体实现中,一旦程序接收到相应的信号,则会执行eng.Shutdown这个函数,在执行完eng.Shutdown之后,随即执行os.Exit(0),完成当前整个Docker Daemon程序的退出。源码实现位于./docker/docker/pkg/signal/trap.go#L33-L47。

3.3.5 加载builtins

DockerDaemon设置完Trap特定信号的处理方法(即eng.shutdown()函数)之后,Docker Daemon实现了builtins的加载。Docker的builtins可以理解为:Docker Daemon运行过程中,注册的一些任务(Job),这部分任务一般与容器的运行无关,与Docker Daemon的运行时信息有关。加载builtins的源码实现如下:

if err := builtins.Register(eng); err != nil {
     log.Fatal(err)
}

加载builtins完成的具体工作是:向engine注册多个Handler,以便后续在执行相应任务时,运行指定的Handler。这些Handler包括:Docker Daemon宿主机的网络初始化、Web API服务、事件查询、版本查看、Docker Registry的验证与搜索等。源码实现位于./docker/docker/builtins/builtins.go#L16-L30,如下:

func Register(eng *engine.Engine) error {
     if err := daemon(eng); err != nil {
          return err
     }
     if err := remote(eng); err != nil {
          return err
     }
     if err := events.New().Install(eng); err != nil {
          return err
     }
     if err := eng.Register("version", dockerVersion); err != nil {
          return err
     }
     return registry.NewService().Install(eng)
}

下面分析Register函数实现过程中最为主要的5个部分:daemon(eng)、remote(eng)、events.New().Install(eng)、eng.Register("version",dockerVersion)以及registry.NewService().Install(eng)。

  1. 注册网络初始化处理方法
    daemon(eng)的实现过程,主要为eng对象注册了一个键为"init_networkdriver"的处理方法,此处理方法的值为bridge.InitDriver函数,源码如下:
func daemon(eng *engine.Engine) error {
     return eng.Register("init_networkdriver", bridge.InitDriver)
}

需要注意的是,向eng对象注册处理方法,并不代表处理方法的值函数会被立即调用执行,如注册init_networkdrive时bridge.InitDriver并不会直接运行,而是将bridge.InitDriver的函数入口作为init_networkdriver的值,写入eng的handlers属性中。当Docker Daemon接收到名为init_networkdriver的Job的执行请求时,bridge.InitDriver才被Docker Daemon调用执行。
Bridge.InitDriver的具体实现位于./docker/docker/daemon/networkdriver/bridge/driver.go#79-L175,主要作用为:
获取为Docker服务的网络设备地址。
创建指定IP地址的网桥。
配置网络iptables规则。
另外还为eng对象注册了多个Handler,如allocate_interface、release_interface、allocate_port以及link等。
本书将在第6章详细分析Docker Daemon如何初始化宿主机的网络环境。

  1. 注册API服务处理方法
    remote(eng)的实现过程,主要为eng对象注册了两个Handler,分别为serveapi与acceptconnections,源码实现如下:
func remote(eng *engine.Engine) error {
     if err := eng.Register("serveapi", apiserver.ServeApi); err != nil {
          return err
     }
     return eng.Register("acceptconnections", apiserver.AcceptConnections)
}

注册的两个处理方法名称分别为serveapi与acceptconnections,相应的执行方法分别为apiserver.ServeApi与apiserver.AcceptConnections,具体实现位于./docker/docker/api/server/server.go。其中,ServeApi执行时,通过循环多种指定协议,创建出goroutine协调来配置指定的http.Server,最终为不同协议的请求服务;而AcceptConnections的作用主要是:通知宿主机上init守护进程Docker Daemon已经启动完毕,可以让Docker Daemon开始服务API请求。

  1. 注册events事件处理方法
    events.New().Install(eng)的实现过程,为Docker注册了多个event事件,功能是给Docker用户提供API,使得用户可以通过这些API查看Docker内部的events信息,log信息以及subscribers_count信息。具体的源码位于./docker/docker/events/events.go#L29-L42,如下所示:
func (e *Events) Install(eng *engine.Engine) error {
     jobs := map[string]engine.Handler{
          "events":            e.Get,
          "log":               e.Log,
          "subscribers_count": e.SubscribersCount,
     }
     for name, job := range jobs {
          if err := eng.Register(name, job); err != nil {
               return err
          }
     }
     return nil
}
  1. 注册版本处理方法
    eng.Register("version",dockerVersion)的实现过程,向eng对象注册key为version,value为dockerVersion执行方法的Handler。dockerVersion的执行过程中,会向名为version的Job的标准输出中写入Docker的版本、Docker API的版本、git版本、Go语言运行时版本,以及操作系统版本等信息。dockerVersion的源码实现如下:
func dockerVersion(job *engine.Job) engine.Status {
     v := &engine.Env{}
     v.SetJson("Version", dockerversion.VERSION)
     v.SetJson("ApiVersion", api.APIVERSION)
     v.Set("GitCommit", dockerversion.GITCOMMIT)
     v.Set("GoVersion", runtime.Version())
     v.Set("Os", runtime.GOOS)
     v.Set("Arch", runtime.GOARCH)
     if kernelVersion, err := kernel.GetKernelVersion(); err == nil {
          v.Set("KernelVersion", kernelVersion.String())
     }
     if _, err := v.WriteTo(job.Stdout); err != nil {
          return job.Error(err)
     }
     return engine.StatusOK
}
  1. 注册registry处理方法
    registry.NewService().Install(eng)的实现过程位于./docker/docker/registry/service.go,功能是:在eng对象对外暴露的API信息中添加docker registry的信息。若registry.NewService()被成功安装,则会有两个相应的处理方法注册至eng,Docker Daemon通过Docker Client提供的认证信息向registry发起认证请求;search,在公有registry上搜索指定的镜像,目前公有的registry只支持Docker Hub。

Install的具体实现如下:

func (s *Service) Install(eng *engine.Engine) error {
     eng.Register("auth", s.Auth)
     eng.Register("search", s.Search)
     return nil
}

至此,Docker Daemon所有builtins的加载全部完成,实现了向eng对象注册特定的处理方法。

3.3.6 使用goroutine加载daemon对象并运行

Docker执行完builtins的加载之后,再次回到mainDaemon()的执行流程中。此时,Docker通过一个goroutine协程加载daemon对象并开始运行Docker Server。这一环节的执行,主要包含以下三个步骤:
1)通过init函数中初始化的daemonCfg与eng对象,创建一个daemon对象d。
2)通过daemon对象的Install函数,向eng对象中注册众多的处理方法。
3)在Docker Daemon启动完毕之后,运行名为acceptconnections的Job,主要工作为向init守护进程发送READY=1信号,以便Docker Server开始正常接收请求。
源码实现位于./docker/docker/docker/daemon.go#L43-L56,如下所示:

go func() {
     d, err := daemon.MainDaemon(daemonCfg, eng)
     if err != nil {
          log.Fatal(err)
     }
     if err := d.Install(eng); err != nil {
          log.Fatal(err)
     }
     if err := eng.Job("acceptconnections").Run(); err != nil {
          log.Fatal(err)
     }
}()

下面详细分析三个步骤所做的工作。

  1. 创建daemon对象
    daemon.NewDaemon(daemonCfg, eng)是创建daemon对象d的核心部分,主要作用是初始化Docker Daemon的基本环境,如处理config参数,验证系统支持度,配置Docker工作目录,设置与加载多种驱动,创建graph环境,验证DNS配置等。

由于daemon.MainDaemon(daemonCfg, eng)是加载Docker Daemon的核心部分,且篇幅过长,本书第4章将深入分析NewDaemon的实现。

  1. 通过daemon对象为engine注册Handler
    Docker创建完daemon对象,goroutine立即执行d.Install(eng),具体实现位于./docker/daemon/daemon.go,代码如下所示:
func (daemon *Daemon) Install(eng *engine.Engine) error {
     for name, method := range map[string]engine.Handler{
          "attach":            daemon.ContainerAttach,
          "build":             daemon.CmdBuild,
          "commit":           daemon.ContainerCommit,
          "container_changes":  daemon.ContainerChanges,
          "container_copy":     daemon.ContainerCopy,
          "container_inspect":   daemon.ContainerInspect,
          "containers":         daemon.Containers,
          "create":            daemon.ContainerCreate,
          "delete":            daemon.ContainerDestroy,
          "export":            daemon.ContainerExport,
          "info":              daemon.CmdInfo,
          "kill":               daemon.ContainerKill,
          ...
          "image_delete":      daemon.ImageDelete, 
     } {
          if err := eng.Register(name, method); err != nil {
               return err
          }
     }
     if err := daemon.Repositories().Install(eng); err != nil {
          return err
     }
     eng.Hack_SetGlobalVar("httpapi.daemon", daemon)
     return nil
}

以上代码的实现同样分为三部分:
向eng对象中注册众多的处理方法对象。
daemon.Repositories().Install(eng)实现了向eng对象注册多个与Docker镜像相关的Handler,Install的实现位于./docker/docker/graph/service.go。
eng.Hack_SetGlobalVar("httpapi.daemon", daemon)实现向eng对象中类型为map的hack对象中添加一条记录,键为httpapi.daemon,值为daemon。

  1. 运行名为acceptconnections的Job
    Docker在goroutine的最后环节运行名为acceptconnections的Job,主要作用是通知init守护进程,使Docker Daemon开始接受请求。源码位于./docke`javascript

r/docker/docker/daemon.go#L53-L55,如下所示:
// after the daemon is done setting up we can tell the api to start
// accepting connections
if err := eng.Job("acceptconnections").Run(); err != nil {

 log.Fatal(err)

}

关于Job的运行流程大同小异,总结而言,都是首先创建特定名称的Job,其次为Job配置环境参数,最后运行Job对应Handler的函数。作为本书涉及的第一个具体Job,下面将对acceptconnections这个Job的执行进程深入分析。
eng.Job("acceptconnections").Run()的运行包含两部分:首先执行eng.Job("acceptconnections"),返回一个Job实例,随后再执行该Job实例的Run()函数。
eng.Job("acceptconnections")的实现位于./docker/docker/engine/engine.go#L115-L137,如下所示:

func (eng Engine) Job(name string, args ...string) Job {

 job := &Job{
      Eng:    eng,
      Name:   name,
      Args:   args,
      Stdin:  NewInput(),
      Stdout: NewOutput(),
      Stderr: NewOutput(),
      env:    &Env{},
 }
 if eng.Logging {
      job.Stderr.Add(utils.NopWriteCloser(eng.Stderr))
 }
 if handler, exists := eng.handlers[name]; exists {
      job.handler = handler
 } else if eng.catchall != nil && name != "" {
      job.handler = eng.catchall
 }
 return job

}

通过分析以上创建Job的源码,我们可以发现Docker首先创建一个类型为Job的job对象,该对象中Eng属性为函数的调用者eng,该对象的Name属性为acceptconnections,没有其他参数传入。另外在eng对象所有的handlers属性中寻找key为acceptconnections所对应的value值(即具体的Handler)。由于在加载builtins时,源码remote(eng)已经向eng注册过这样一条记录,键为acceptconnections,值为apiserver.AcceptConnections。因此,Job对象的handler属性为apiserver.AcceptConnections。最后函数返回已经初始化完毕的对象Job。
创建完Job对象之后,随即执行该job对象的run()函数。run()函数的源码实现位于./docker/docker/engine/job.go#L48-L96,该函数执行指定的Job,并在Job执行完成前一直处于阻塞状态。对于名为acceptconnections的Job对象,运行代码为job.status = job.handler(job),由于job.handler值为apiserver.AcceptConnections,故真正执行的是job.status = apiserver.AcceptConnections(job)。
AcceptConnections的具体实现属于Docker Server的范畴,深入研究Docker Server可以发现,这部分源码位于./docker/docker/api/server/server.go#L1370-L1380,如下所示:

func AcceptConnections(job *engine.Job) engine.Status {

 // Tell the init daemon we are accepting requests
 go systemd.SdNotify("READY=1")
 if activationLock != nil {
      close(activationLock)
 }
 return engine.StatusOK

}

AcceptConnections函数的重点是go systemd.SdNotify("READY=1")的实现,位于
./docker/docker/pkg/system/sdnotify.go#L12-L33,主要作用是通知init守护进程Docker Daemon的启动已经全部完成,潜在的功能是要求Docker Daemon开始接收并服务Docker Client发送来的API请求。
至此,通过goroutine来加载daemon对象并运行启动Docker Server的工作全部完成。
###3.3.7 打印Docker版本及驱动信息
Docker再次回到mainDaemon()的运行流程,由于Go语言goroutine的性质,在goroutine执行之时,mainDaemon()函数内部其他代码也会并发执行。
第一个执行的即为显示Docker的版本信息、GitCommit信息、ExecDriver和GraphDriver这两个驱动的具体信息,源码如下:

log.Printf("docker daemon: %s %s; execdriver: %s; graphdriver: %s",

 dockerversion.VERSION,
 dockerversion.GITCOMMIT,
 daemonCfg.ExecDriver,
 daemonCfg.GraphDriver,

)

###3.3.8 serveapi的创建与运行
打印Docker的部分具体信息之后,Docker Daemon立即创建并运行名为serveapi的Job,主要作用为让Docker Daemon提供Docker Client发起的API服务。实现代码位于./docker/docker/docker/daemon.go#L66,如下所示:

job := eng.Job("serveapi", flHosts...)
job.SetenvBool("Logging", true)
job.SetenvBool("EnableCors", *flEnableCors)
job.Setenv("Version", dockerversion.VERSION)
job.Setenv("SocketGroup", *flSocketGroup)

job.SetenvBool("Tls", *flTls)
job.SetenvBool("TlsVerify", *flTlsVerify)
job.Setenv("TlsCa", *flCa)
job.Setenv("TlsCert", *flCert)
job.Setenv("TlsKey", *flKey)
job.SetenvBool("BufferRequests", true)
if err := job.Run(); err != nil {

 log.Fatal(err)

}

以上代码标志着Docker Daemon真正进入状态。实现过程中,Docker首先创建一个名为serveapi的Job,并将flHosts的值赋给job.Args。flHosts的作用主要是:为Docker Daemon提供使用的协议与监听的地址。随后,Docker Daemon为该Job设置了众多的环境变量,如安全传输层协议的环境变量等。最后通过job.Run()运行该serveapi的Job。
由于在eng中key为serveapi的handler,value为apiserver.ServeApi,故该Job运行时,执行apiserver.ServeApi函数,位于./docker/docker/api/server/server.go。ServeApi函数的作用是:对于所有用户定义支持协议,Docker Daemon均创建一个goroutine来启动相应的http.Server,并为每一种协议服务。
由于创建并启动http.Server为Docker架构中有关Docker Server的重要内容,本书将在第5章深入介绍Docker Server。

版权声明:本文内容由阿里云实名注册用户自发贡献,版权归原作者所有,阿里云开发者社区不拥有其著作权,亦不承担相应法律责任。具体规则请查看《阿里云开发者社区用户服务协议》和《阿里云开发者社区知识产权保护指引》。如果您发现本社区中有涉嫌抄袭的内容,填写侵权投诉表单进行举报,一经查实,本社区将立刻删除涉嫌侵权内容。

分享:

华章出版社

官方博客
官网链接