예제 #1
0
파일: storage.go 프로젝트: m1911/hyper
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)
}
예제 #2
0
파일: daemon.go 프로젝트: Oliverlyn/hyper
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
}