docker containerd 中的create 容器操作

containerd的create container的API如下所示：

type CreateContainerRequest struct {

　　Id　　　　　　 string
　　BundlePath　　string
　　Checkpoint　　 string
　　Stdin　　　　　string
　　Stdout　　　　 string
　　Stderr　　　　 string
　　Labels　　　　[]string
　　NoPivotRoot　 bool
　　Runtime　　　 string
　　RuntimeArgs　[]string
　　CheckpointDir  string
}

　　

StartTask结构如下所示：

type StartTask struct {

　　baseTask

　　ID　　　　　　string
　　BundlePath　　string
　　Stdout　　　　 string
　　Stderr　　　　  string
　　Stdin　　　　　string
　　StartResponse   chan StartResponse
　　Labels　　　　  []string
　　NoPivotRoot　　bool
　　Checkpoint　　  *runtime.Checkpoint
　　CheckpointDir　  string
　　Runtime　　　　 string
　　RuntimeArgs　　 []string
}

　　

1、containerd/api/grpc/server/server.go

func (s *apiServer) CreateContainer(ctx context.Context, c *types.CreateContainerRequest) (*types.CreateContainerResponse, error)

（1）、根据c填充获得e := &supervisor.StartTask{}，并调用s.sv.SendTask(e)

（2）、调用 r := <-e.StartResponse，再调用apiC ,err := createAPIContainer(r.Container, false)获取创建的容器实例

（3）、return &types.CreateContainerResponse{Container: apiC,}

2、containerd/supervisor/create.go

func (s *Supervisor) start(t *StartTask) error

（1）、根据t的内容创建容器，runtime.New主要根据ContainerOpts填充结构container获得容器实例，再将创建state并写入状态文件中。

container, err := runtime.New(runtime.ContainerOpts{

　　Root:　　　　s.stateDir,
　　ID:　　　　　t.ID,
　　Bundle:　　　t.BundlePath,
　　Runtime:　　 rt,
　　RuntimeArgs: rtArgs,

　　Shim:　　　　s.shim,

　　Labels:　　　 t.Labels,
　　NoPivotRoot:  t.NoPivotRoot,
　　Timeout:　　　s.timeout
})

　　

（2）、注册新增加的容器，调用s.containers[t.ID] = &containerInfo{container: container,}

（3）、根据新获得的container实例和t的内容，填充获得startTask，再调用s.startTask <- task 交由worker处理

task := &startTask{

　　Err:　　　　　　t.ErrorCh(),
　　Container:　　　container,
　　StartResponse:　t.StartResponse,
　　Stdin:　　　　　  t.Stdin,
　　Stdout:　　　　　t.Stdout,
　　Stderr:　　　　　t.Stderr
}

　　

3、containerd/supervisor/worker.go

// Start runs a loop in charge of starting new containers

func (w *Worker) Start()

containerd在刚创建时，就启动了10个goroutine，用于处理startTasks，这里的Start函数就是从startTasks这个channel中获取任务，并处理

（1）、调用process, err := t.Container.Start(t.checkpointPath, runtime.NewStdio(t.Stdin, t.Stdout, t.Stderr))启动容器，NewStdio()仅仅只是将参数封装到一个统一的Stdio结构中

（2）、分别调用w.s.monitor.MonitorOOM(t.Container)，w.s.monitorProcess(process)对容器进行监控，调用t.StartResponse <- StartResponse{Container: t.Container}返回创建成功的容器实例

4、containerd/runtime/container.go

func (c *container) Start(checkpointPath string, s Stdio) (Process, error)

（1）、创建processRoot := filepath.Join(c.root, c.id, InitProcessID)目录

（2）、容器创建命令 cmd := exec.Command(c.shim, c.id, c.bundle, c.runtime)，配置cmd目录为processRoot，spec, err := c.readSpec()

（3）、生成config如下：

config := &processConfig {

　　checkpoint:　　　　checkpointPath,
　　root:　　　　　　　processRoot,
　　id:　　　　　　　　InitProcessID,
　　c:　　　　　　　　 c,
　　stdio:　　　　　　  s,
　　spec:　　　　　　  spec,
　　processSpec:　　　specs.ProcessSpec(spec.Process),

}

　　

（4）、根据config，调用p, err := newProcess(config)，生成process实例

（5）、最后调用c.createCmd(InitProcessID, cmd, p)，并返回 return p, nil

5、containerd/runtime/process.go

func newProcess(config *processConfig) (*process, error)

（1）、根据config生成process实例，p := &process{root: config.root, id: config.id, container: config.c, ....., cmdDoneCh: make(chan struct{}), state: Running,}

（2）、创建状态文件os.Create(filepath.Join(config.root, "process.config"))，生成ps := ProcessState{...}，并将ps的内容写入状态文件中

（3）、调用exit, err := getExitPipe(filepath.Join(config.root, ExitFile))和control ,err := getControlPipe(filepath.Join(config.root, ControlFile))生成两个pipe文件，并分别将exit和control赋值给p.exitPipe和p.controlPipe，最后 return p

6、containerd/runtime/process.go

getExitPipe和getControlPipe生成两个FIFO文件，其中Exit函数中的FIFO是只读的，而Control函数中的FIFO是读写的

7、containerd/runtime/container.go

func (c *container) createCmd(pid string, cmd *exec.Cmd, p *process)

（1）、p.cmd = cmd, 再调用 cmd.Start()

（2）、构建defer函数，其中生成一个goroutine，其中调用p.cmd.Wait()，再调用same, err := p.isSameProcess()，如果same为true并且p.pid > 0则再进行一些处理

（3）、调用c.waitForCreate(p, cmd)，c.processes[pid] = p

8、containerd/runtime/container.go

func (c *container) waitForCreate(p *process, cmd *exec.Cmd) error

（1）、该函数先启动一个goroutine用于从pidfile中读取pid

（2）、select，从（1）中的goroutine接收结果，或者超时，当超时时，调用cmd.Process.Kill()和cmd.Wait()