runv start container 流程分析

1、runv/start.go

func startContainer(context *cli.Context, container, address string, config *spec.Spec)

该函数所做的工作很简单，首先构建CreateContainerRequest的grpc请求，如下所示：

r  := &types.CreateContainerRequest {

　　Id:　　　　　  container,
　　BundlePath:     context.String("bundle"),
　　Stdin:　　　　 fmt.Sprintf("/proc/%d/fd/0", pid),
　　Stdout:　　　   fmt.Sprintf("/proc/%d/fd/1", pid),
　　Stderr:　　　　fmt.Sprintf("/proc/%d/fd/2", pid),
}

　　

再通过调用c := getClient(address)获取grpc client，再通过调用c.CreateContainer(netcontext.Background(), r)将创建容器的请求发送给grpc server。

2、runv/containerd/api/grpc/server/server.go

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

（1）、调用ocfData, err := ioutil.ReadFile(filepath.Join(r.BundlePath, "config.json"))和json.Unmarshal(ocfData, &spec)加载spec

（2）、调用c, p, err := s.sv.CreateContainer(r.Id, r.BundlePath, r.Stdin, r.Stdout, r.Stderr, &spec)

（3）、最后调用apiP := supervisorProcess2ApiProcess(p)， apiC := supervisorContainer2ApiContainer(c), addApiProcess2ApiContainer(apiC, apiP)完成api的转换，并且将进程apiP添加到apiC中

3、runv/supervisor/supervisor.go

func (sv *Supervisor) CreateContainer(container, bundlePath, stdin, stdout, stderr string, spec *specs.Spec) (*Container, *Process, error)

（1）、调用hp, err := sv.getHyperPod(container, spec)，获取一个hyper pod 实例

（2）、c, err := hp.createContainer(container, bundlePath, stdin, stdout, stderr, spec) 创建一个hyper container实例

（3）、sv.Containers[container] = c, 再 return c, c.Processes["init"], nil

HyperPod的结构如下所示：

type HyperPod struct {

　　Containers　　map[string]*Container
　　Processes　　map[string]*Process
　　userPod　　　　*pod.UserPod
　　podStatus　　*hypervisor.PodStatus
　　vm　　　　　*hypervisor.Vm
　　sv　　　　　　*supervisor
　　nslistener　　*nsListener
}

　　

4、runv/supervisor/supervisor.go

// find shared pod or create a new one

func (sv *Supervisor) getHyperPod(container string, spec *specs.Spec) (hp *HyperPod, err error)

（1）、当spec.Linux.Namespaces不为空时，先进行相关的处理，这里暂时不讨论。

（2）、当hp为nil时，先调用hp, err = createHyperPod(sv.Factory, spec, sv.defaultCpus, sv.defaultMemory),再调用hp.sv = sv将hypervisor和supervisor串联起来

（3）、return hp, nil

5、runv/supervisor/hyperpod.go

func createHyperPod(f factory, spec *specs.Spec, defaultCpus int, defaultMemory int) (*HyperPod, error)

（1）、先获取一个podId，再调用userPod := pod.ConvertOCF2PureUserPod(spec)(并没有container的信息)和podStatus := hypervisor.NewPod(podId, userPod, nil)

（2）、获取cpu, mem, kernel, initrd的信息，再启动虚拟机，虽然根据获得的kernel和initrd情况略有不同，最终调用都是调用hypervisor.GetVm("", boot, bool, bool)，启动虚拟机

（3）、调用Response := vm.StartPod(podStatus, userPod, nil, nil)

（4）、填充HyperPod, hp := &HyperPod {

　　　　　　　　　　　　　　userPod:　　userPod,

　　　　　　　　　　　　　　podStatus:　podStatus,

　　　　　　　　　　　　　　vm:　　　　vm,

　　　　　　　　　　　　　　Containers:　make(map[string]*Container),

　　　　　　　　　　　　　　Processes:　make(map[string]*Process)

　　　　　　　　　　　　}

（5）、调用hp.startNsListener()， 返回 return hp, nil

6、runv/supervisor/hyperpod.go

func (hp *HyperPod) createContainer(container, bundlePath, stdin, stdout, stderr string, spec *specs.Spec) (*Container, error)

（1）、inerProcessId := container + "-init"，并且填充数据结构获得 c := &Container{...}，p := &Process{...}

（2）、调用p.setupIO()

（3）、对各个数据结构进行关联，c.Processes["init"] = p, c.ownerPod.Processes[inerProcessId] = p, c.ownerPod.Containers[container] = c

（4）、c.run(p)，return c, nil

7、runv/supervisor/container.go

func (c *Container) run(p *Process)

（1）、该函数仅仅启动一个goroutine，首先调用c.start(p)启动容器

（2）、创建e := Event{ID: c.Id, Type: EventContainerStart, Timestamp: time.Now(),}，调用c.ownerPod.sv.Events.notifySubscribers(e)将event发出

（3）、调用c.wait(p)等待容器退出

（4）、创建e := Event{ID: c.Id, EventExit, Timestamp: time.Now(), PID: p.Id, Status: -1}，若正常退出，则将Status设置为容器的退出码

8、runv/supervisor/container.go

func (c *Container) start(p *Process) error

（1）、创建目录/run/runv/container-id，再在其中生成文件state.go，将state := &specs.State{Version: c.Spec.Version, ID: c.Id, Pid: c.ownerPod.getNsPid(), BundlePath: c.BundlePath}写入

（2）、先调用u := pod.ConvertOCF2UserContainer(c.Spec)将spec转换为UserPod，镜像目录为u.Image，镜像的挂载目录为vmRootfs := filepath.Join(hypervisor.BaseDir, c.ownerPod.vm.Id, hypervisor.ShareDirTag, c.Id, "rootfs")（和hyperd兼容），再调用utils.Mount(u.Image, vmRootfs, c.Spec.Root.Readonly)将镜像挂载到vmRootfs。如果c.Spec.Mounts不为空的话，调用mountToRootfs(&m, vmRootfs, "")，挂载相应的目录或文件

（3）、调用info := &hypervisor.ContainerInfo{Id: c.Id, Rootfs: "rootfs", Image: pod.userVolume{Source: c.Id}, Fstype: "dir", Cmd: u.Command, Envs: envs,}

（4）、调用c.ownerPod.vm.Attach(p.stdio, c.Id, nil)连接vm, 再调用execPrestartHooks(c.Spec, state)，再调用c.ownerPod.initPodNetwork(c)初始化网络

（5）、调用c.ownerPod.podStatus.AddContainer(c.Id, c.ownerPod.podStatus.Id, "", []string{}, types.S_POD_CREATED) ---> 仅仅只是将ContainerStatus添加到podStatus.Containers中

（6）、return c.ownerPod.vm.NewContainer(u, info) ---> 真正在虚拟机中完成container的创建