func dissociateSandbox(sandbox *hypervisor.Vm, retry int) error {
if sandbox == nil {
return nil
}
rval, err := sandbox.ReleaseVm()
if err != nil {
hlog.Log(WARNING, "SB[%s] failed to release sandbox: %v", sandbox.Id, err)
if rval == runvtypes.E_BUSY && retry < maxReleaseRetry {
retry++
hlog.Log(DEBUG, "SB[%s] retry release %d", sandbox.Id, retry)
time.AfterFunc(100*time.Millisecond, func() {
dissociateSandbox(sandbox, retry)
})
return nil
}
hlog.Log(INFO, "SB[%s] shutdown because of failed release", sandbox.Id)
sandbox.Kill()
return err
}
return nil
}
func createHyperPod(f factory.Factory, spec *specs.Spec, defaultCpus int, defaultMemory int) (*HyperPod, error) {
podId := fmt.Sprintf("pod-%s", pod.RandStr(10, "alpha"))
userPod := pod.ConvertOCF2PureUserPod(spec)
podStatus := hypervisor.NewPod(podId, userPod, nil)
cpu := defaultCpus
if userPod.Resource.Vcpu > 0 {
cpu = userPod.Resource.Vcpu
}
mem := defaultMemory
if userPod.Resource.Memory > 0 {
mem = userPod.Resource.Memory
}
kernel := chooseKernel(spec)
initrd := chooseInitrd(spec)
glog.V(3).Infof("Using kernel: %s; Initrd: %s; vCPU: %d; Memory %d", kernel, initrd, cpu, mem)
var (
vm *hypervisor.Vm
err error
)
if len(kernel) == 0 && len(initrd) == 0 {
vm, err = f.GetVm(cpu, mem)
if err != nil {
glog.V(1).Infof("Create VM failed with default kernel config: %s", err.Error())
return nil, err
}
glog.V(3).Infof("Creating VM with default kernel config")
} else if len(kernel) == 0 || len(initrd) == 0 {
// if user specify a kernel, they must specify an initrd at the same time
return nil, fmt.Errorf("You must specify an initrd if you specify a kernel, or vice-versa")
} else {
boot := &hypervisor.BootConfig{
CPU: cpu,
Memory: mem,
Kernel: kernel,
Initrd: initrd,
}
vm, err = hypervisor.GetVm("", boot, true, false)
if err != nil {
glog.V(1).Infof("Create VM failed: %s", err.Error())
return nil, err
}
glog.V(3).Infof("Creating VM with specific kernel config")
}
Response := vm.StartPod(podStatus, userPod, nil, nil)
if Response.Data == nil {
vm.Kill()
glog.V(1).Infof("StartPod fail: QEMU response data is nil\n")
return nil, fmt.Errorf("StartPod fail")
}
glog.V(1).Infof("result: code %d %s\n", Response.Code, Response.Cause)
hp := &HyperPod{
userPod: userPod,
podStatus: podStatus,
vm: vm,
Containers: make(map[string]*Container),
Processes: make(map[string]*Process),
}
// create Listener process running in its own netns
if err = hp.startNsListener(); err != nil {
hp.reap()
glog.V(1).Infof("start ns listener fail: %s\n", err.Error())
return nil, err
}
return hp, nil
}
func createHyperPod(f factory.Factory, spec *specs.Spec, defaultCpus int, defaultMemory int) (*HyperPod, error) {
cpu := defaultCpus
mem := defaultMemory
if spec.Linux != nil && spec.Linux.Resources != nil && spec.Linux.Resources.Memory != nil && spec.Linux.Resources.Memory.Limit != nil {
mem = int(*spec.Linux.Resources.Memory.Limit >> 20)
}
kernel := chooseKernel(spec)
initrd := chooseInitrd(spec)
glog.V(3).Infof("Using kernel: %s; Initrd: %s; vCPU: %d; Memory %d", kernel, initrd, cpu, mem)
var (
vm *hypervisor.Vm
err error
)
if len(kernel) == 0 && len(initrd) == 0 {
vm, err = f.GetVm(cpu, mem)
if err != nil {
glog.V(1).Infof("Create VM failed with default kernel config: %s", err.Error())
return nil, err
}
glog.V(3).Infof("Creating VM with default kernel config")
} else if len(kernel) == 0 || len(initrd) == 0 {
// if user specify a kernel, they must specify an initrd at the same time
return nil, fmt.Errorf("You must specify an initrd if you specify a kernel, or vice-versa")
} else {
boot := &hypervisor.BootConfig{
CPU: cpu,
Memory: mem,
Kernel: kernel,
Initrd: initrd,
}
vm, err = hypervisor.GetVm("", boot, true, false)
if err != nil {
glog.V(1).Infof("Create VM failed: %s", err.Error())
return nil, err
}
glog.V(3).Infof("Creating VM with specific kernel config")
}
r := make(chan api.Result, 1)
go func() {
r <- vm.WaitInit()
}()
sandbox := api.SandboxInfoFromOCF(spec)
vm.InitSandbox(sandbox)
rsp := <-r
if !rsp.IsSuccess() {
vm.Kill()
glog.V(1).Infof("StartPod fail, response: %v", rsp)
return nil, fmt.Errorf("StartPod fail")
}
glog.V(1).Infof("%s init sandbox successfully", rsp.ResultId())
hp := &HyperPod{
vm: vm,
Containers: make(map[string]*Container),
Processes: make(map[string]*Process),
}
// create Listener process running in its own netns
if err = hp.startNsListener(); err != nil {
hp.reap()
glog.V(1).Infof("start ns listener fail: %s\n", err.Error())
return nil, err
}
return hp, nil
}
