前言

上节[mydocker]---构造容器02-实现资源限制02中已经加入了对memory的限制. 本节将会加入管道功能, 通常进程间使用管道进行通信, 所以本文将对之前进程间传输的command用管道的方式来执行.

代码: 代码下载
tag: code-3.3

效果

root@nicktming:~/go/src/github.com/nicktming# pwd
/root/go/src/github.com/nicktming
root@nicktming:~/go/src/github.com/nicktming# git clone https://github.com/nicktming/mydocker.git
root@nicktming:~/go/src/github.com/nicktming# cd mydocker
root@nicktming:~/go/src/github.com/nicktming/mydocker# git checkout code-3.3
root@nicktming:~/go/src/github.com/nicktming/mydocker# go build .
root@nicktming:~/go/src/github.com/nicktming/mydocker# ./mydocker run -it /bin/sh
2019/04/03 23:26:14 read from commandline:
2019/04/03 23:26:14 read from pipe:/bin/sh
# ps -ef
UID        PID  PPID  C STIME TTY          TIME CMD
root         1     0  0 23:26 pts/2    00:00:00 /bin/sh
root         4     1  0 23:26 pts/2    00:00:00 ps -ef
# 

可以看到容器执行的用户程序命令/bin/sh是从管道中读取的.

了解管道

多个进程在协作完成同一任务时,通常彼此要传输数据,共享资源.

匿名管道：shell 中的 pipe 就是匿名管道，只能在父子进程 / 有亲缘关系的进程之间使用.
命名管道：允许无亲缘关系的进程间传输数据.

由于代码中使用的是命名管道,因此接下来通过两个简单的例子来了解一下管道是如何工作.

例子1

非常简单的一个例子, 同步操作, 先用管道的写端写数据,然后管道的读端读数据.

func Test001(t *testing.T) {
    reader, writer, err := os.Pipe()
    if err != nil {
        log.Fatalf("os.pipe error:%v\n", err)
    }
    _, err = writer.Write([]byte("pipe content"))
    if err != nil {
        log.Fatalf("writer.Write error:%v\n", err)
    }

    buf := make([]byte, 20)
    n, err := reader.Read(buf)
    if err != nil {
        log.Fatalf("reader.Read(buf) error:%v\n", err)
    }
    log.Printf("Read Content:%q\n", string(buf[:n]))
}

执行操作

root@nicktming:~/go/src/github.com/nicktming/mydocker/test/pipe# go test -v pipe_test.go -test.run Test001
=== RUN   Test001
2019/04/03 23:34:14 Read Content:"pipe content"
--- PASS: Test001 (0.00s)
PASS
ok      command-line-arguments  0.002s

例子2

将上面的例子从同步改成异步, 启动两个goroutine一个写端一直写10次, 管道的读端读管道里面的所有内容.

func Test002(t *testing.T) {
    reader, writer, err := os.Pipe()
    if err != nil {
        log.Fatalf("os.pipe error:%v\n", err)
    }
    go func() {
        for i := 0; i < 10; i++ {
            content := fmt.Sprintf("%s-%d\n", "pipe content", i)
            _, err = writer.Write([]byte(content))
            if err != nil {
                log.Fatalf("writer.Write error:%v\n", err)
            }
        }
        writer.Close()
    }()

    go func() {
        n, err := ioutil.ReadAll(reader)
        if err != nil {
            log.Fatalf("reader.Read(buf) error:%v\n", err)
        }
        log.Printf("Read Content:%q\n", n)
    }()

    for i := 0; i <= 100; i++{
        time.Sleep(1 * time.Second)
    }
}

执行, 注意只有等到管道写端Close()后读端才可以读到所有的内容.

root@nicktming:~/go/src/github.com/nicktming/mydocker/test/pipe# go test -v pipe_test.go -test.run Test002
=== RUN   Test002
2019/04/04 00:16:03 Read Content:"pipe content-0\npipe content-1\npipe content-2\npipe content-3\npipe content-4\npipe content-5\npipe content-6\npipe content-7\npipe content-8\npipe content-9\n"

实现

其实实现也是比较比较简单, 就是把原先/proc/self/exe init /bin/sh改成/proc/self/exe并且把command(/bin/sh)通过管道传输. 也就是在run方法中生成管道并用写端把comand写进去后关闭写端. 利用cmd把管道的读端传输给子进程, 然后在子进程中用管道读端读取command从而执行该command.

1. command/run.go

在此文件中将Run方法改动如下

a. reader, writer, err := os.Pipe()
b. cmd := exec.Command("/proc/self/exe", "init")不再把用户命令传输该init中.
c. 新增sendInitCommand方法使用管道写端将command写进去.
d. 因为init中需要用到该管道的读端, 因此使用cmd.ExtraFiles = []*os.File{reader}将其传输.

func Run(command string, tty bool, cg *cgroups.CroupManger)  {
    //cmd := exec.Command(command)

    reader, writer, err := os.Pipe()
    if err != nil {
        log.Printf("Error: os.pipe() error:%v\n", err)
        return
    }

    //cmd := exec.Command("/proc/self/exe", "init", command)

    cmd := exec.Command("/proc/self/exe", "init")

    cmd.SysProcAttr = &syscall.SysProcAttr{
        Cloneflags: syscall.CLONE_NEWUTS | syscall.CLONE_NEWPID | syscall.CLONE_NEWNS | syscall.CLONE_NEWNET | syscall.CLONE_NEWIPC,
    }

    cmd.ExtraFiles = []*os.File{reader}
    sendInitCommand(command, writer)

    if tty {
        cmd.Stderr = os.Stderr
        cmd.Stdout = os.Stdout
        cmd.Stdin = os.Stdin
    }
    /**
     *   Start() will not block, so it needs to use Wait()
     *   Run() will block
     */
    if err := cmd.Start(); err != nil {
        log.Printf("Run Start err: %v.\n", err)
        log.Fatal(err)
    }
    //log.Printf("222 before process pid:%d, memory:%s\n", cmd.Process.Pid, memory)

    //subsystems.Set(memory)
    //subsystems.Apply(strconv.Itoa(cmd.Process.Pid))
    //defer subsystems.Remove()

//  sendInitCommand(command, writer)

    cg.Set()
    defer cg.Destroy()
    cg.Apply(strconv.Itoa(cmd.Process.Pid))

    cmd.Wait()
}

func sendInitCommand(command string, writer *os.File)  {
    _, err := writer.Write([]byte(command))
    if err != nil {
        log.Printf("writer.Write error:%v\n", err)
        return
    }
    writer.Close()
}

2. command/init.go

与上面对应的此处改动如下:

a. command从命令行中获取的值为“”
b. 新增一个函数负责利用管道的读端来获得run方法中传输过来的command. 其中reader := os.NewFile(uintptr(3), "pipe")的uintptr(3)就是指index 为3 的文件描述符，也就是传递进来的管道的一端

func Init(command string)  {

    log.Printf("read from commandline:%s\n", command)

    command = readFromPipe()

    log.Printf("read from pipe:%s\n", command)

    defaultMountFlags := syscall.MS_NOEXEC | syscall.MS_NOSUID | syscall.MS_NODEV
    syscall.Mount("proc", "/proc", "proc", uintptr(defaultMountFlags), "")

    /*
    cmd := exec.Command(command)

    cmd.Stdin = os.Stdin
    cmd.Stderr = os.Stderr
    cmd.Stdout = os.Stdout

    if err := cmd.Run(); err != nil {
        log.Printf("Init Run() function err : %v\n", err)
        log.Fatal(err)
    }
    */

    if err := syscall.Exec(command, []string{command}, os.Environ()); err != nil {
        log.Printf("syscall.Exec err: %v\n", err)
        log.Fatal(err)
    }
}

func readFromPipe() string {
    reader := os.NewFile(uintptr(3), "pipe")
    command, err := ioutil.ReadAll(reader)
    if err != nil {
        log.Printf("reader.Read(buf) error:%v\n", err)
        return ""
    }
    return string(command)
}

时序图

code-3.3.png

参考

1. https://wuyin.io/2019/02/19/ipc-pipe/
2. 自己动手写docker.(基本参考此书,加入一些自己的理解,加深对docker的理解)

全部内容

mydocker.png

1. [mydocker]---环境说明
2. [mydocker]---urfave cli 理解
3. [mydocker]---Linux Namespace
4. [mydocker]---Linux Cgroup
5. [mydocker]---构造容器01-实现run命令
6. [mydocker]---构造容器02-实现资源限制01
7. [mydocker]---构造容器02-实现资源限制02
8. [mydocker]---构造容器03-实现增加管道
9. [mydocker]---通过例子理解存储驱动AUFS
10. [mydocker]---通过例子理解chroot 和 pivot_root
11. [mydocker]---一步步实现使用busybox创建容器
12. [mydocker]---一步步实现使用AUFS包装busybox
13. [mydocker]---一步步实现volume操作
14. [mydocker]---实现保存镜像
15. [mydocker]---实现容器的后台运行
16. [mydocker]---实现查看运行中容器
17. [mydocker]---实现查看容器日志
18. [mydocker]---实现进入容器Namespace
19. [mydocker]---实现停止容器
20. [mydocker]---实现删除容器
21. [mydocker]---实现容器层隔离
22. [mydocker]---实现通过容器制作镜像
23. [mydocker]---实现cp操作
24. [mydocker]---实现容器指定环境变量
25. [mydocker]---网际协议IP
26. [mydocker]---网络虚拟设备veth bridge iptables
27. [mydocker]---docker的四种网络模型与原理实现(1)
28. [mydocker]---docker的四种网络模型与原理实现(2)
29. [mydocker]---容器地址分配
30. [mydocker]---网络net/netlink api 使用解析
31. [mydocker]---网络实现
32. [mydocker]---网络实现测试