func (daemon *Daemon) initRunV(c *apitypes.HyperConfig) error {
var (
err error
)
if hypervisor.HDriver, err = driverloader.Probe(c.Driver); err != nil {
glog.Warningf("%s", err.Error())
glog.Errorf("Please specify the correct and available hypervisor, such as 'kvm', 'qemu-kvm', 'libvirt', 'xen', 'qemu', or ''")
return err
}
daemon.Hypervisor = c.Driver
glog.Infof("The hypervisor's driver is %s", c.Driver)
daemon.Factory = factory.NewFromPolicy(c.Kernel, c.Initrd, c.VmFactoryPolicy)
return nil
}
func mainDaemon(opt *Options) {
config := opt.Config
glog.V(1).Infof("The config file is %s", config)
if config == "" {
config = "/etc/hyper/config"
}
if _, err := os.Stat(config); err != nil {
if os.IsNotExist(err) {
glog.Errorf("Can not find config file(%s)", config)
return
}
glog.Errorf(err.Error())
return
}
os.Setenv("HYPER_CONFIG", config)
cfg, err := goconfig.LoadConfigFile(config)
if err != nil {
glog.Errorf("Read config file (%s) failed, %s", config, err.Error())
return
}
hyperRoot, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Root")
if hyperRoot == "" {
hyperRoot = "/var/lib/hyper"
}
utils.HYPER_ROOT = hyperRoot
if _, err := os.Stat(hyperRoot); err != nil {
if err := os.MkdirAll(hyperRoot, 0755); err != nil {
glog.Errorf(err.Error())
return
}
}
storageDriver, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "StorageDriver")
daemon.InitDockerCfg(strings.Split(opt.Mirrors, ","), strings.Split(opt.InsecureRegistries, ","), storageDriver, hyperRoot)
d, err := daemon.NewDaemon(cfg)
if err != nil {
glog.Errorf("The hyperd create failed, %s", err.Error())
return
}
vbox.Register(d)
serverConfig := &server.Config{}
defaultHost := "unix:///var/run/hyper.sock"
Hosts := []string{defaultHost}
if opt.Hosts != "" {
Hosts = append(Hosts, opt.Hosts)
}
if d.Host != "" {
Hosts = append(Hosts, d.Host)
}
for i := 0; i < len(Hosts); i++ {
var err error
if Hosts[i], err = opts.ParseHost(defaultHost, Hosts[i]); err != nil {
glog.Errorf("error parsing -H %s : %v", Hosts[i], err)
return
}
protoAddr := Hosts[i]
protoAddrParts := strings.SplitN(protoAddr, "://", 2)
if len(protoAddrParts) != 2 {
glog.Errorf("bad format %s, expected PROTO://ADDR", protoAddr)
return
}
serverConfig.Addrs = append(serverConfig.Addrs, server.Addr{Proto: protoAddrParts[0], Addr: protoAddrParts[1]})
}
api, err := server.New(serverConfig)
if err != nil {
glog.Errorf(err.Error())
return
}
api.InitRouters(d)
driver, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Hypervisor")
driver = strings.ToLower(driver)
if hypervisor.HDriver, err = driverloader.Probe(driver); err != nil {
glog.Warningf("%s", err.Error())
glog.Errorf("Please specify the correct and available hypervisor, such as 'kvm', 'qemu-kvm', 'libvirt', 'xen', 'qemu', 'vbox' or ''")
return
} else {
d.Hypervisor = driver
glog.Infof("The hypervisor's driver is %s", driver)
}
disableIptables := cfg.MustBool(goconfig.DEFAULT_SECTION, "DisableIptables", false)
if err = hypervisor.InitNetwork(d.BridgeIface, d.BridgeIP, disableIptables || opt.DisableIptables); err != nil {
glog.Errorf("InitNetwork failed, %s", err.Error())
return
}
defaultLog, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Logger")
defaultLogCfg, _ := cfg.GetSection("Log")
d.DefaultLogCfg(defaultLog, defaultLogCfg)
// Set the daemon object as the global varibal
// which will be used for puller and builder
utils.SetDaemon(d)
if err := d.Restore(); err != nil {
glog.Warningf("Fail to restore the previous VM")
return
}
vmFactoryPolicy, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "VmFactoryPolicy")
d.Factory = factory.NewFromPolicy(d.Kernel, d.Initrd, vmFactoryPolicy)
rpcHost, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "gRPCHost")
if rpcHost != "" {
rpcServer := serverrpc.NewServerRPC(d)
defer rpcServer.Stop()
go func() {
err := rpcServer.Serve(rpcHost)
if err != nil {
glog.Fatalf("Hyper serve RPC error: %v", err)
}
}()
}
// The serve API routine never exits unless an error occurs
// We need to start it as a goroutine and wait on it so
// daemon doesn't exit
serveAPIWait := make(chan error)
go api.Wait(serveAPIWait)
stopAll := make(chan os.Signal, 1)
signal.Notify(stopAll, syscall.SIGINT, syscall.SIGTERM)
stop := make(chan os.Signal, 1)
signal.Notify(stop, syscall.SIGHUP)
glog.V(0).Infof("Hyper daemon: %s %s",
utils.VERSION,
utils.GITCOMMIT,
)
// Daemon is fully initialized and handling API traffic
// Wait for serve API job to complete
select {
case errAPI := <-serveAPIWait:
// If we have an error here it is unique to API (as daemonErr would have
// exited the daemon process above)
if errAPI != nil {
glog.Warningf("Shutting down due to ServeAPI error: %v", errAPI)
}
break
case <-stop:
d.DestroyAndKeepVm()
break
case <-stopAll:
d.DestroyAllVm()
break
}
d.Factory.CloseFactory()
api.Close()
d.Shutdown()
}