docker源码学习-main
众所周知，docker client和docker server共用一个可执行文件，通过命令行参数来区分是client还是server。
喵一眼main函数源码：
docker/docker.go
func main() {
// 为了exedriver
if reexec.Init() {
return
}
// 命令行参数解析
flag.Parse()
// FIXME: validate daemon flags here
// 在docker编译时实现
if *flVersion {
showVersion()
return
}
if *flDebug {
os.Setenv("DEBUG", "1")
}
// flHosts是docker server监听，docker连接的地址
if len(flHosts) == 0 {
defaultHost := os.Getenv("DOCKER_HOST")
if defaultHost == "" || *flDaemon {
// If we do not have a host, default to unix socket
defaultHost = fmt.Sprintf("unix://%s", api.DEFAULTUNIXSOCKET)
}
defaultHost, err := api.ValidateHost(defaultHost)
if err != nil {
log.Fatal(err)
}
flHosts = append(flHosts, defaultHost)
}以上代码四个要点：
0.reexec.Init是为了exedriver，分析到driver部分再说；
1.命令行参数用到flag表解析，不赘述；
2.flVersion代码编译时实现的版本控制；
3.flHosts是docker server监听，docker连接的地址。
好继续往下看：
docker/docker.go:
// 说明启动的是docer daemon,也就是docker server,也就是说后边代码不在执行
if *flDaemon {
mainDaemon()
return
}
if len(flHosts) > 1 {
log.Fatal("Please specify only one -H")
}
// protoAddrParts解析出 Docker Client 与 Docker Server建立通信的协议与地址
protoAddrParts := strings.SplitN(flHosts[0], "://", 2)
var (
cli *client.DockerCli // client对象
tlsConfig tls.Config // tls协议配置
)
tlsConfig.InsecureSkipVerify = true//默认不启用
// If we should verify the server, we need to load a trusted ca
// 如果启用TLS,则读ca文件
if *flTlsVerify {
*flTls = true
certPool := x509.NewCertPool()
file, err := ioutil.ReadFile(*flCa)
if err != nil {
log.Fatalf("Couldn't read ca cert %s: %s", *flCa, err)
}
certPool.AppendCertsFromPEM(file)
tlsConfig.RootCAs = certPool
tlsConfig.InsecureSkipVerify = false
}
// If tls is enabled, try to load and send client certificates
if *flTls || *flTlsVerify {
_, errCert := os.Stat(*flCert)
_, errKey := os.Stat(*flKey)
if errCert == nil && errKey == nil {
*flTls = true
cert, err := tls.LoadX509KeyPair(*flCert, *flKey)
if err != nil {
log.Fatalf("Couldn't load X509 key pair: %s. Key encrypted?", err)
}
tlsConfig.Certificates = []tls.Certificate{cert}
}
// Avoid fallback to SSL protocols < TLS1.0
tlsConfig.MinVersion = tls.VersionTLS10
}
以上代码可以看出：
1.docker中如何实现客户端服务端同文件；
2.docker可选支持TLS安全传输协议。
okay看到这里以及看完了docker命令行解析，接下来看客户端启动和服务端启动吧。
客户端启动：
// 启动客户端
if *flTls || *flTlsVerify {
cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, nil, protoAddrParts[0], protoAddrParts[1], &tlsConfig)
} else {
cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, nil, protoAddrParts[0], protoAddrParts[1], nil)
}
// 把命令行参数传过去
if err := cli.Cmd(flag.Args()...); err != nil {
if sterr, ok := err.(*utils.StatusError); ok {
if sterr.Status != "" {
log.Infof("%s", sterr.Status)
}
os.Exit(sterr.StatusCode)
}
log.Fatal(err)
}再看看client包中的NewDockerCli代码：
func NewDockerCli(in io.ReadCloser, out, err io.Writer, key libtrust.PrivateKey, proto, addr string, tlsConfig *tls.Config) *DockerCli {
var (
inFd uintptr
outFd uintptr
isTerminalIn = false
isTerminalOut = false
scheme = "http"
)
// 这样就走https了
if tlsConfig != nil {
scheme = "https"
}
if in != nil {
if file, ok := in.(*os.File); ok {
inFd = file.Fd()
isTerminalIn = term.IsTerminal(inFd)
}
}
if out != nil {
if file, ok := out.(*os.File); ok {
outFd = file.Fd()
isTerminalOut = term.IsTerminal(outFd)
}
}
if err == nil {
err = out
}
// The transport is created here for reuse during the client session
tr := &http.Transport{
TLSClientConfig: tlsConfig,
Dial: func(dial_network, dial_addr string) (net.Conn, error) {
// Why 32? See issue 8035
return net.DialTimeout(proto, addr, 32*time.Second)
},
}
if proto == "unix" {
// no need in compressing for local communications
tr.DisableCompression = true
}
return &DockerCli{
proto: proto,
addr: addr,
in: in,
out: out,
err: err,
key: key,
inFd: inFd,
outFd: outFd,
isTerminalIn: isTerminalIn,
isTerminalOut: isTerminalOut,
tlsConfig: tlsConfig,
scheme: scheme,
transport: tr,
}
}
以上代码有一个要点：proto是DockerClient 与 Docker Server 的传输协议
具体的DockerCli类实现，稍后继续
下面看看 cli.Cmd(flag.Args()…)，究竟是咋个情况。撸一下
// Cmd executes the specified command
func (cli *DockerCli) Cmd(args ...string) error {
if len(args) > 1 {
method, exists := cli.getMethod(args[:2]...)
if exists {
return method(args[2:]...)
}
}
if len(args) > 0 {
method, exists := cli.getMethod(args[0])
if !exists {
fmt.Println("Error: Command not found:", args[0])
return cli.CmdHelp(args[1:]...)
}
return method(args[1:]...)
}
// 说明没传入参数，那就返回其帮助信息
return cli.CmdHelp(args...)
}其实就是用命令行参数拼出方法名，然后反射把方法返回，然后传参给返回的方法来执行。很优雅，以后做命令行的程序可以借鉴这种方法。为方便理解我把这段代码拉出来改了一下，如下所示：
package main
import (
"fmt"
"reflect"
"strings"
)
type Client struct {
name string
}
func (cli *Client) CmdHelp(args ...string) error {
fmt.Println("func CmdHelp")
return nil
}
func (cli *Client) CmdPull(args ...string) error {
fmt.Println("func CmdPull")
fmt.Println(args)
return nil
}
func (cli *Client) getMethod(args ...string) (func(...string) error, bool) {
camelArgs := make([]string, len(args))
for i, s := range args {
if len(s) == 0 {
return nil, false
}
camelArgs[i] = strings.ToUpper(s[:1]) + strings.ToLower(s[1:])
}
methodName := "Cmd" + strings.Join(camelArgs, "")
method := reflect.ValueOf(cli).MethodByName(methodName)
if !method.IsValid() {
return nil, false
}
return method.Interface().(func(...string) error), true
}
func (cli *Client) Cmd(args ...string) error {
if len(args) > 1 {
method, exists := cli.getMethod(args[:2]...)
if exists {
return method(args[2:]...)
}
}
if len(args) > 0 {
method, exists := cli.getMethod(args[0])
if !exists {
fmt.Println("Error: Command not found:", args[0])
return cli.CmdHelp(args[1:]...)
}
return method(args[1:]...)
}
return cli.CmdHelp(args...)
}
func main() {
var cli *Client
cli.Cmd("pull", "1", "2", "3")
}以上代码打印：
func CmdPull
[1 2 3]
可以看到调用了CmdPull,并且参数成功传入了函数CmdPull。docker源码中也是一样，看下CmdPull源码：
func (cli *DockerCli) CmdPull(args ...string) error {
cmd := cli.Subcmd("pull", "NAME[:TAG]", "Pull an image or a repository from the registry")
tag := cmd.String([]string{"#t", "#-tag"}, "", "Download tagged image in a repository")
if err := cmd.Parse(args); err != nil {
return nil
}
if cmd.NArg() != 1 {
cmd.Usage()
return nil
}
var (
v = url.Values{}
remote = cmd.Arg(0)
)
// 把要拉取的镜像存到了v中
v.Set("fromImage", remote)
if *tag == "" {
v.Set("tag", *tag)
}
remote, _ = parsers.ParseRepositoryTag(remote)
// Resolve the Repository name from fqn to hostname + name
hostname, _, err := registry.ResolveRepositoryName(remote)
if err != nil {
return err
}
cli.LoadConfigFile()
// Resolve the Auth config relevant for this server
authConfig := cli.configFile.ResolveAuthConfig(hostname)
// 创建pull函数，作用是向docker server 发送Post命令，其中/images/create?"+v.Encode()为url部分，map[string][]string{
"X-Registry-Auth": registryAuthHeader,为认证信息
pull := func(authConfig registry.AuthConfig) error {
buf, err := json.Marshal(authConfig)
if err != nil {
return err
}
registryAuthHeader := []string{
base64.URLEncoding.EncodeToString(buf),
}
return cli.stream("POST", "/images/create?"+v.Encode(), nil, cli.out, map[string][]string{
"X-Registry-Auth": registryAuthHeader,
})
}
if err := pull(authConfig); err != nil {
if strings.Contains(err.Error(), "Status 401") {
fmt.Fprintln(cli.out, "\nPlease login prior to pull:")
if err := cli.CmdLogin(hostname); err != nil {
return err
}
authConfig := cli.configFile.ResolveAuthConfig(hostname)
return pull(authConfig)
}
return err
}
ok，至此docker clinet已经启动成功，下一篇我写一下学习docker deamon的笔记
路漫漫，其修远兮