Docker从精通到入门(二)----Docker Client
昌山
########
获取docker1.2的源码
docker pull docker-dev:v1.2.0
docker run --rm -it --privileged -e BUILDFLAGS -e DOCKER_CLIENTONLY -e DOCKER_EXECDRIVER -e DOCKER_EXPERIMENTAL -e DOCKER_GRAPHDRIVER -e DOCKER_STORAGE_OPTS -e DOCKER_USERLANDPROXY -e TESTDIRS -e TESTFLAGS -e TIMEOUT -v ./docker120:/go/src/github.com/docker/docker/bundles docker-dev:v1.2.0 bash
cd /go/src
tar zcf src.tar.gz /github.com
再开一个终端
docker cp $(docker ps -aq):/go/src/src.tar.gz .
#########
一、Docker Client
1. 创建一个Docker Client：
· 如何通过dokcer命令，解析出命令行flag参数，以及docker命令中的请求参数
· 如何处理具体的flag参数信息，并收集Docker Client所需的配置信息
· 如何创建一个Docker Client
2. 如何执行docker命令
· 分析如何解析docker命令中的请求参数，获取相应的请求类型；
· 分析Docker Client如何执行具体的请求命令，最终将请求发送到Docker Sever。
二、创建Docker Client
// docker.go contains Docker's main function.
// This file provides first line CLI argument parsing and environment variable setting.
· Docker是一个Client/Sever的架构，客户端用于docker任务的发起；
用户首先需要创建一个Client，随后将特定的请求类型与参数传递给Client；
由Client转义成Sevrr能识别的形式，并发送至Server。
· Clint的创建实质上是用户通过二进制可执行文件docker，创建与Server建立联系的客户端；
1. docker命令的flag参数解析
· 在Docker的具体实现中，Dcoker Sever与Docker Client均由docker文件创建；
如何区分 Client和Sever 是创建Client的第一步；
· Docker请求中的参数大致分为两类：
第一类是命令行参数：比如，-D、--daemon=false；
第二类是实际请求参数：比如，pull、run；
· 第一类称为flag参数，在Go语言的标准库中可以使用flags包进行命令行参数的解析；
func main() {
if reexec.Init() {
return
}
flag.Parse()
// FIXME: validate daemon flags here
...
}
最开始先判断reexec.Init()方法返回值是否为真，为真直接返回；
reexec.Init()的作用是创建一个空的flags接受map，并验证是否创建成功，如果不成功返回真，对应到main.main中就是直接返回
然后根据设置在docker/docker/flags.go对应的全局变量和init()函数中的初始化flags，解析命令行中的参数
...
flDaemon = flag.Bool([]string{"d", "-daemon"}, false, "Enable daemon mode")
...
定义flDaemon=flag.Bool([]string{"d", "-daemon"}, false, "Enable daemon mode")
flDaemon的类型为Bool类型
flDaemon默认为false
flDaemon名称为 "d" 或 "-daemon"
flDaemon的用途信息为 "Enable daemon mode"
访问flDaemon的值，使用 *flDaemon解引用访问
即 -d 或--daemon=true.... 就能触发 flDaemon
当遇到第一个非参数时说明flags参数解析停止，再将后续的非flags参数存到 flag.Arg()中，以便于执行Docker Client具体的请求时使用；
2. 处理flag信息并收集Docker
将收集到的flags参数，按照对应的处理方式做出对应的处理
func main() {
...
if *flVersion {
showVersion()
return
}
if *flDebug {
os.Setenv("DEBUG", "1")
}
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)
}
if _, err := api.ValidateHost(defaultHost); err != nil {
log.Fatal(err)
}
flHosts = append(flHosts, defaultHost)
}
if *flDaemon {
mainDaemon()
return
}
...
// 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}
}
}
...
}
根据所有的flag参数已经全部处理完毕，Docker-Client收集到了所有所需的配置信息。
3. 如何创建Docker client
Client的创建其实就是再已有配置参数信息的情况下，开始创建实例cli：
func main(){
...
if *flTls || *flTlsVerify {
cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, protoAddrParts[0], protoAddrParts[1], &tlsConfig)
} else {
cli = client.NewDockerCli(os.Stdin, os.Stdout, os.Stderr, protoAddrParts[0], protoAddrParts[1], nil)
}
if err := cli.Cmd(flag.Args()...); err != nil {
if sterr, ok := err.(*utils.StatusError); ok {
if sterr.Status != "" {
log.Println(sterr.Status)
}
os.Exit(sterr.StatusCode)
}
log.Fatal(err)
}
}
若flag参数fITIs为真或者flTLsVerify为真，说明需要使用TLS协议来保障传输的安全性；，
创建Docker Client的时候，将tlsConfig参数传入；
创建Docker对象cli的过程比较简单，较为重要的DockerCli属性有：
port：Docker Client与Docker Server的传输协议；
addr：Docker Client需要访问的host目标地址；
若tlsConfig：不为空，则说明需要使用安全传输层协议，Dockercli的scheme设置为"https"；
另外还有关于输入、输出以及错误显示的配置等，最终返回一个DockerCli。
func NewDockerCli(in io.ReadCloser, out, err io.Writer, proto, addr string, tlsConfig *tls.Config) *DockerCli {
var (
isTerminal = false
terminalFd uintptr
scheme = "http"
)
if tlsConfig != nil {
scheme = "https"
}
if in != nil {
if file, ok := out.(*os.File); ok {
terminalFd = file.Fd()
isTerminal = term.IsTerminal(terminalFd)
}
}
if err == nil {
err = out
}
return &DockerCli{
proto: proto,
addr: addr,
in: in,
out: out,
err: err,
isTerminal: isTerminal,
terminalFd: terminalFd,
tlsConfig: tlsConfig,
scheme: scheme,
}
}
创建Docker Client结束
三、执行docker指令
· 解析请求命令
main()执行完毕，现在有Docker Client和docker命令中的请求参数( flag解析后存放于flasg.Arg() )；
也就是说，程序需要使用Docker Client 来分析Docker命令中的请求参数，
· 发起请求
得出请求的类型，转义为Docker Server可以识别的请求之后，最终发送给Docker Sever。
1. Docker Client解析请求命令
创建Docker Client之后，根据之前Args命令集合解析请求命令，如果解析命令有错误则返回错误指示；
解析请求如下：
// Cmd executes the specified command
func (cli *DockerCli) Cmd(args ...string) error {
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...)
}
在以上源码中，首先判断请求参数列表的长度是否大于0；
如果长度不大于0，说明没有请求消息，返回docker命令的Help信息；
若长度大于1，则说明有请求信息，那么Docker Client首先通过请求参数列表中第一个元素args[0]来获取具体的请求方法method；
若上述method方法不存在，则返回docker命令的Help信息，
若存在，调用具体的method方法，参数为arg[1]及其之后所有的参数，
func (cli *DockerCli) getMethod(name string) (func(...string) error, bool) {
if len(name) == 0 {
return nil, false
}
methodName := "Cmd" + strings.ToUpper(name[:1]) + strings.ToLower(name[1:])
method := reflect.ValueOf(cli).MethodByName(methodName)
if !method.IsValid() {
return nil, false
}
return method.Interface().(func(...string) error), true
}
2. Docker Client执行请求命令
通过命令解析，找到了具体的方法，接下来需要通过得到的方法，处理并发送请求。
· 以 docker pull Image 为例，本命令的作用是去Registry中下载指定镜像
执行cli.Cmd()在getMethod()获取了CmdPull方法，执行CmdPull("Image")；
在CmdPull(Image)中：
a. 首先通过cli.Subcmd定义一个flag.FlagSet的cmd对象
b. 将args参数进行第二次flags解析，将参数存入cmd.NArg
c. 判断args中的参数个数
d. 创建一个map类型的变量v，该变量用于存放下拉镜像所需的URL参数；
随后将参数列表的第一个值cmd.Arg(0)付给remote作为fromImage的值添加到V；
e. 通过remote变量首先得到镜像库Registry的名称，并赋给remote自身，随后通过解析改变后的remote，
得出镜像所在的host地址，即Docker Registry的地址。
如果用户没有定制Docker Registry的地址，则Docker默认地址为Docker Hub地址 https://index.docker.io/v1/
f. 通过cli对象获取与Docker Server通信所需要的认证配置信息；
g. 定义一个名为pull的函数，传入的参数类型为registry.AuthConfig，返回为error，
向Docker Server发送一个Post请求，请求的url为"/images/create?"+v.Encode()；
请求的认证信息为： map[string][]string{"X-Registry-Auth": registryAuthHeader,}
h. 执行pull函数，发送下载请求
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.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 := 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
}
return nil
}
请求执行过程中，大多数都是将命令行中关于请求的参数进行初步处理，并添加相应的辅助信息，
最终通过指定的协议向Docker Server发送 Docker Client和Docker Server约定好的API请求。
类似资料：