docker中run的示例分析

1）获取libcontainerd模块中的containers

2）获取gid和uid

3）创建state目录，配置文件路径。

4）创建一个containercommon对象，创建容器目录，以及配置文件路径，根据spec创建配置文件。

1) 读取spec对象的配置文件

2) 创建一个fifo的pipe

3) 定义containerd的请求对象，grpc调用containerd模块。

ctr.client.remote.apiClient.CreateContainer(context.Background(), r)

4）启动成功后，更新容器状态。

type Supervisor struct {
	// stateDir is the directory on the system to store container runtime state information.
	stateDir string
	// name of the OCI compatible runtime used to execute containers
	runtime     string
	runtimeArgs []string
	shim        string
	containers  map[string]*containerInfo
	startTasks  chan *startTask //这是containerd到runc的桥梁，由func (w *worker) Start()消费
	// we need a lock around the subscribers map only because additions and deletions from
	// the map are via the API so we cannot really control the concurrency
	subscriberLock sync.RWMutex
	subscribers    map[chan Event]struct{}
	machine        Machine
	tasks          chan Task //所有来自于docker-daemon的request都会转化为event存放到这，由func (s *Supervisor) Start()消费
	monitor        *Monitor
	eventLog       []Event
	eventLock      sync.Mutex
	timeout        time.Duration
}
type startTask struct {
	Container      runtime.Container
	CheckpointPath string
	Stdin          string
	Stdout         string
	Stderr         string
	Err            chan error
	StartResponse  chan StartResponse
}

docker-daemon
--->tasks chan Task
 --->func (s *Supervisor) Start()消费
   --->存放到startTasks  chan *startTask
      -->func (w *worker) Start()消费

func daemon(context *cli.Context) error {
	s := make(chan os.Signal, 2048)
	signal.Notify(s, syscall.SIGTERM, syscall.SIGINT)
	/*
		新建一个supervisor，这个是containerd的核心部件
			==>/supervisor/supervisor.go
				==>func New
	*/
	sv, err := supervisor.New(
		context.String("state-dir"),
		context.String("runtime"),
		context.String("shim"),
		context.StringSlice("runtime-args"),
		context.Duration("start-timeout"),
		context.Int("retain-count"))
	if err != nil {
		return err
	}
	wg := &sync.WaitGroup{}
	/*
		supervisor 启动10个worker
			==>/supervisor/worker.go
	*/
	for i := 0; i < 10; i++ {
		wg.Add(1)
		w := supervisor.NewWorker(sv, wg)
		go w.Start()
	}
	//启动supervisor
	if err := sv.Start(); err != nil {
		return err
	}
    // Split the listen string of the form proto://addr
	/*
		根据参数获取监听器
		listenSpec的值为 unix:///var/run/docker/libcontainerd/docker-containerd.sock
	*/
	listenSpec := context.String("listen")
	listenParts := strings.SplitN(listenSpec, "://", 2)
	if len(listenParts) != 2 {
		return fmt.Errorf("bad listen address format %s, expected proto://address", listenSpec)
	}
	/*
		启动grpc server端
	*/
	server, err := startServer(listenParts[0], listenParts[1], sv)
	if err != nil {
		return err
	}

// SendTask sends the provided event to the the supervisors main event loop
/*
	SendTask将evt Task发送给 the supervisors main event loop
	所有来自于docker-daemon的request都会转化为event存放到这，生产者
*/
func (s *Supervisor) SendTask(evt Task) {
	TasksCounter.Inc(1) //任务数+1
	s.tasks <- evt
}

root@idc-gz:/var/run/docker/libcontainerd# tree -L 2 eb347b7e27ecbc01f009971a13cb1b24a89baad795f703053de26d9722129039/
eb347b7e27ecbc01f009971a13cb1b24a89baad795f703053de26d9722129039/
├── 95de4070f528e1d68c80142f679013815a2d1a00da7858c390ad4895b8f8991b-stdin
├── 95de4070f528e1d68c80142f679013815a2d1a00da7858c390ad4895b8f8991b-stdout
├── config.json
├── dc172589265f782a476af1ed302d3178887d078c737ff3d18b930cbc143e5fd5-stdin
├── dc172589265f782a476af1ed302d3178887d078c737ff3d18b930cbc143e5fd5-stdout
├── ef00cfa54bf014e3f732af3bda1f667c9b0f79c0d865f099b1bee014f0834844-stdin
├── ef00cfa54bf014e3f732af3bda1f667c9b0f79c0d865f099b1bee014f0834844-stdout
├── init-stdin
└── init-stdout
root@idc-gz:/var/run/docker/libcontainerdcontainerd# tree -L 2 eb347b7e27ecbc01f009971a13cb1b24a89baad795f703053de26d9722129039/
eb347b7e27ecbc01f009971a13cb1b24a89baad795f703053de26d9722129039/
├── dc172589265f782a476af1ed302d3178887d078c737ff3d18b930cbc143e5fd5
│   ├── control
│   ├── exit
│   ├── log.json
│   ├── pid
│   ├── process.json
│   ├── shim-log.json
│   └── starttime
├── ef00cfa54bf014e3f732af3bda1f667c9b0f79c0d865f099b1bee014f0834844
│   ├── control
│   ├── exit
│   ├── log.json
│   ├── pid
│   ├── process.json
│   ├── shim-log.json
│   └── starttime
├── init
│   ├── control
│   ├── exit
│   ├── log.json
│   ├── pid
│   ├── process.json
│   ├── shim-log.json
│   └── starttime
└── state.json

// LinuxFactory implements the default factory interface for linux based systems.
type LinuxFactory struct {
	// Root directory for the factory to store state.
	/*
		factory 存放数据的根目录  默认是 /run/runc
		而/run/runc/{containerID} 目录下，会有两个文件：
          一个是管道exec.fifo
		  一个是state.json
	*/
	Root string

	// InitArgs are arguments for calling the init responsibilities for spawning
	// a container.
	/*
		用于设置 init命令 ，固定是 InitArgs:  []string{"/proc/self/exe", "init"},
	*/
	InitArgs []string

	// CriuPath is the path to the criu binary used for checkpoint and restore of
	// containers.
	// 用于checkpoint and restore
	CriuPath string

	// Validator provides validation to container configurations.
	Validator validate.Validator

	// NewCgroupsManager returns an initialized cgroups manager for a single container.
	// 初始化一个针对单个容器的cgroups manager
	NewCgroupsManager func(config *configs.Cgroup, paths map[string]string) cgroups.Manager
}

// 一个容器负责对应一个runner
type runner struct {
	enableSubreaper bool
	shouldDestroy   bool
	detach          bool
	listenFDs       []*os.File
	pidFile         string
	console         string
	container       libcontainer.Container
	create          bool
}