func (dms *DevMapperStorage) Init() error {
dmPool := dm.DeviceMapper{
Datafile: path.Join(utils.HYPER_ROOT, "lib") + "/data",
Metadatafile: path.Join(utils.HYPER_ROOT, "lib") + "/metadata",
DataLoopFile: DEFAULT_DM_DATA_LOOP,
MetadataLoopFile: DEFAULT_DM_META_LOOP,
PoolName: dms.VolPoolName,
Size: DEFAULT_DM_POOL_SIZE,
}
dms.DmPoolData = &dmPool
rand.Seed(time.Now().UnixNano())
// Prepare the DeviceMapper storage
return dm.CreatePool(&dmPool)
}
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())
}
})
if os.Geteuid() != 0 {
return nil, fmt.Errorf("The Hyper 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)
vboxImage, _ := cfg.GetValue(goconfig.DEFAULT_SECTION, "Vbox")
glog.V(0).Infof("The config: vbox image=%s", vboxImage)
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 = path.Join(utils.HYPER_ROOT, "run")
os.Setenv("TMPDIR", tempdir)
if err := os.MkdirAll(tempdir, 0755); err != nil && !os.IsExist(err) {
return nil, err
}
var realRoot = path.Join(utils.HYPER_ROOT, "lib")
// Create the root directory if it doesn't exists
if err := os.MkdirAll(realRoot, 0755); err != nil && !os.IsExist(err) {
return nil, err
}
var (
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, err1 := NewDocker()
if err1 != nil {
glog.Errorf(err1.Error())
return nil, err1
}
pList := map[string]*hypervisor.Pod{}
vList := map[string]*hypervisor.Vm{}
daemon := &Daemon{
ID: fmt.Sprintf("%d", os.Getpid()),
db: db,
eng: eng,
Kernel: kernel,
Initrd: initrd,
Bios: bios,
Cbfs: cbfs,
VboxImage: vboxImage,
DockerCli: dockerCli,
PodList: pList,
PodsMutex: new(sync.RWMutex),
VmList: vList,
Host: host,
BridgeIP: bridgeip,
BridgeIface: biface,
}
stor := &Storage{}
// Get the docker daemon info
sysinfo, err := dockerCli.SendCmdInfo()
if err != nil {
return nil, err
}
storageDriver := sysinfo.Driver
stor.StorageType = storageDriver
if storageDriver == "devicemapper" {
for _, pair := range sysinfo.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 storageDriver == "aufs" {
for _, pair := range sysinfo.DriverStatus {
if pair[0] == "Root Dir" {
stor.RootPath = pair[1]
}
if pair[0] == "Backing Filesystem" {
stor.Fstype = "dir"
break
}
}
} else if storageDriver == "overlay" {
for _, pair := range sysinfo.DriverStatus {
if pair[0] == "Backing Filesystem" {
stor.Fstype = "dir"
break
}
}
stor.RootPath = path.Join(utils.HYPER_ROOT, "overlay")
} else if storageDriver == "vbox" {
stor.Fstype = "ext4"
stor.RootPath = path.Join(utils.HYPER_ROOT, "vbox")
} else {
return nil, fmt.Errorf("hyperd can not support docker's backing storage: %s", storageDriver)
}
daemon.Storage = stor
dmPool := dm.DeviceMapper{
Datafile: path.Join(utils.HYPER_ROOT, "lib") + "/data",
Metadatafile: path.Join(utils.HYPER_ROOT, "lib") + "/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
}