func NewDaemonFromDirectory(eng *engine.Engine) (*Daemon, error) {
// register portallocator release on shutdown
eng.OnShutdown(func() {
if err := portallocator.ReleaseAll(); err != nil {
glog.Errorf("portallocator.ReleaseAll(): %s", err.Error())
}
})
// Check that the system is supported and we have sufficient privileges
if runtime.GOOS != "linux" {
return nil, fmt.Errorf("The Docker daemon is only supported on linux")
}
if os.Geteuid() != 0 {
return nil, fmt.Errorf("The Docker daemon needs to be run as root")
}
if err := checkKernel(); err != nil {
return nil, err
}
cfg, err := goconfig.LoadConfigFile(eng.Config)
if err != nil {
glog.Errorf("Read config file (%s) failed, %s", eng.Config, err.Error())
return nil, err
}
kernel, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Kernel")
initrd, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Initrd")
glog.V(0).Infof("The config: kernel=%s, initrd=%s", kernel, initrd)
biface, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Bridge")
bridgeip, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "BridgeIP")
glog.V(0).Infof("The config: bridge=%s, ip=%s", biface, bridgeip)
bios, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Bios")
cbfs, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Cbfs")
glog.V(0).Infof("The config: bios=%s, cbfs=%s", bios, cbfs)
host, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Host")
var tempdir = "/var/run/hyper/"
os.Setenv("TMPDIR", tempdir)
if err := os.MkdirAll(tempdir, 0755); err != nil && !os.IsExist(err) {
return nil, err
}
var realRoot = "/var/lib/hyper/"
// Create the root directory if it doesn't exists
if err := os.MkdirAll(realRoot, 0755); err != nil && !os.IsExist(err) {
return nil, err
}
if err := network.InitNetwork(biface, bridgeip); err != nil {
glog.Errorf("InitNetwork failed, %s\n", err.Error())
return nil, err
}
var (
proto = "unix"
addr = "/var/run/docker.sock"
db_file = fmt.Sprintf("%s/hyper.db", realRoot)
)
db, err := leveldb.OpenFile(db_file, nil)
if err != nil {
glog.Errorf("open leveldb file failed, %s\n", err.Error())
return nil, err
}
dockerCli := docker.NewDockerCli("", proto, addr, nil)
qemuchan := map[string]interface{}{}
qemuclient := map[string]interface{}{}
subQemuClient := map[string]interface{}{}
cList := []*Container{}
pList := map[string]*Pod{}
vList := map[string]*Vm{}
daemon := &Daemon{
ID: fmt.Sprintf("%d", os.Getpid()),
db: db,
eng: eng,
kernel: kernel,
initrd: initrd,
bios: bios,
cbfs: cbfs,
dockerCli: dockerCli,
containerList: cList,
podList: pList,
vmList: vList,
qemuChan: qemuchan,
qemuClientChan: qemuclient,
subQemuClientChan: subQemuClient,
Host: host,
}
stor := &Storage{}
// Get the docker daemon info
body, _, err := dockerCli.SendCmdInfo()
if err != nil {
return nil, err
}
outInfo := engine.NewOutput()
remoteInfo, err := outInfo.AddEnv()
if err != nil {
return nil, err
}
if _, err := outInfo.Write(body); err != nil {
return nil, fmt.Errorf("Error while reading remote info!\n")
}
outInfo.Close()
storageDriver := remoteInfo.Get("Driver")
stor.StorageType = storageDriver
if storageDriver == "devicemapper" {
if remoteInfo.Exists("DriverStatus") {
var driverStatus [][2]string
if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {
return nil, err
}
for _, pair := range driverStatus {
if pair[0] == "Pool Name" {
stor.PoolName = pair[1]
}
if pair[0] == "Backing Filesystem" {
if strings.Contains(pair[1], "ext") {
stor.Fstype = "ext4"
} else if strings.Contains(pair[1], "xfs") {
stor.Fstype = "xfs"
} else {
stor.Fstype = "dir"
}
break
}
}
}
} else {
if remoteInfo.Exists("DriverStatus") {
var driverStatus [][2]string
if err := remoteInfo.GetJson("DriverStatus", &driverStatus); err != nil {
return nil, err
}
for _, pair := range driverStatus {
if pair[0] == "Root Dir" {
stor.RootPath = pair[1]
}
if pair[0] == "Backing Filesystem" {
stor.Fstype = "dir"
break
}
}
}
}
daemon.Storage = stor
dmPool := dm.DeviceMapper{
Datafile: "/var/lib/hyper/data",
Metadatafile: "/var/lib/hyper/metadata",
DataLoopFile: "/dev/loop6",
MetadataLoopFile: "/dev/loop7",
PoolName: "hyper-volume-pool",
Size: 20971520 * 512,
}
if storageDriver == "devicemapper" {
daemon.Storage.DmPoolData = &dmPool
// Prepare the DeviceMapper storage
if err := dm.CreatePool(&dmPool); err != nil {
return nil, err
}
} else {
daemon.CleanVolume(0)
}
eng.OnShutdown(func() {
if err := daemon.shutdown(); err != nil {
glog.Errorf("Error during daemon.shutdown(): %v", err)
}
})
return daemon, nil
}
