Esempio n. 1
0
func (hardDisks HardDiskMap) AddHardDisks(xmlHardDisk *xmlHardDisk, parent *uuid.UUID, dir string) (disk *HardDisk, err error) {
	diskUUID, err := uuid.ParseHex(xmlHardDisk.UUID)
	if err != nil {
		return nil, err
	}
	disk = &HardDisk{
		UUID:      *diskUUID,
		Location:  xmlHardDisk.Location,
		Format:    xmlHardDisk.Format,
		Type:      xmlHardDisk.Type,
		AutoReset: xmlHardDisk.AutoReset,
		Parent:    parent,
	}

	if !path.IsAbs(disk.Location) {
		disk.Location = path.Join(dir, disk.Location)
	}

	lenChildDisks := len(xmlHardDisk.Children)
	if lenChildDisks != 0 {
		disk.Children = make([]*uuid.UUID, lenChildDisks)
		for index, childXmlDisk := range xmlHardDisk.Children {
			childDisk, err := hardDisks.AddHardDisks(&childXmlDisk, &disk.UUID, dir)
			if err != nil {
				return nil, err
			}
			disk.Children[index] = &childDisk.UUID
		}
	}

	hardDisks[*diskUUID] = disk

	return disk, nil
}
Esempio n. 2
0
func (p *Proxy) machineInstanceHandler(w http.ResponseWriter, r *http.Request) {
	params := r.URL.Query()
	uuidString := params.Get(":uuid")
	if uuidString == "" {
		sendJsonError(w, errors.New("Was expecting uuid."))
		return
	}
	uuid, err := uuid.ParseHex(uuidString)
	if err != nil {
		err := fmt.Errorf("Could not parse uuid: %s error: %s", uuidString, err)
		sendJsonError(w, err)
		return
	}
	machine, ok := p.VirtualBox.Machines[*uuid]
	if !ok {
		err := fmt.Errorf("Could not find machine with uuid: %s.", uuidString)
		sendJsonError(w, err)
		return
	}

	op := params.Get(":op")
	switch op {
	case "stop":
		p.stopVmHandler(w, r, machine)
	case "start":
		p.startVmHandler(w, r, machine)
	}
}
Esempio n. 3
0
func extractUUIDs(text string) (uuids []*uuid.UUID) {
	re, err := regexp.Compile("([[:xdigit:]]{8}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{4}-[[:xdigit:]]{12})")
	if err != nil {
		log.Fatal("Failed to compile UUID regexp.")
	}

	uuidStrings := re.FindAllString(text, -1)
	uuids = make([]*uuid.UUID, len(uuidStrings))
	for index, uuidString := range uuidStrings {
		uuid, err := uuid.ParseHex(uuidString)
		if err != nil {
			log.Fatal("Failed to compile parse UUID despite validating regexp.")
		}
		uuids[index] = uuid
	}
	return uuids
}
Esempio n. 4
0
// Load the given configuration file
func Decode(configPath string) (vbox *VirtualBox, err error) {
	runningMachineUUIDs, err := runningMachineUUIDs()
	if err != nil {
		return
	}

	// top level xml file
	file, err := os.Open(configPath)
	if err != nil {
		return
	}
	machineList := new(xmlMachineList)
	err = xml.NewDecoder(file).Decode(machineList)
	if err != nil {
		return
	}

	// per machine xml file
	vbox = new(VirtualBox)
	vbox.Machines = make(MachineMap, len(machineList.Machines))
	vbox.HardDisks = make(HardDiskMap)

	for _, machineListEntry := range machineList.Machines {
		file, err := os.Open(machineListEntry.Source)
		if err != nil {
			return nil, err
		}

		xmlMachineRoot := new(xmlMachineRoot)
		err = xml.NewDecoder(file).Decode(xmlMachineRoot)
		if err != nil {
			return nil, err
		}

		if len(xmlMachineRoot.Machines) != 1 {
			return nil, errors.New("Was expecting exactly 1 machine.")
		}
		xmlMachine := xmlMachineRoot.Machines[0]

		machineUUID, err := uuid.ParseHex(machineListEntry.UUID)
		if err != nil {
			return nil, err
		}

		status := Off
		if runningMachineUUIDs[*machineUUID] {
			status = Running
		}

		vrdePort := 0
		if xmlMachine.RemoteDisplay.Enabled {
			vrdePortString := findProperty(&xmlMachine.RemoteDisplay.Properties,
				"TCP/Ports")
			if vrdePortString != "" {
				vrdePort, err = strconv.Atoi(vrdePortString)
				if err != nil {
					return nil, err
				}
			}
		}

		seleniumPort := 0
		for _, forwarding := range xmlMachine.Forwarding {
			if forwarding.Name == "selenium" {
				seleniumPort = forwarding.HostPort
			}
		}

		machine := &Machine{
			UUID:         *machineUUID,
			Source:       machineListEntry.Source,
			Name:         xmlMachine.Name,
			OSType:       OSType(xmlMachine.OSType),
			Status:       status,
			VRDEPort:     vrdePort,
			SeleniumPort: seleniumPort,
		}

		for _, xmlHardDisk := range xmlMachine.RegisteredHardDisks {
			_, err := vbox.HardDisks.AddHardDisks(
				&xmlHardDisk, nil, path.Dir(machine.Source))
			if err != nil {
				return nil, err
			}
		}

		machine.HardDisks = make([]*uuid.UUID, len(xmlMachine.AttachedHardDisks))
		for index, attachedImage := range xmlMachine.AttachedHardDisks {
			imageUUID, err := uuid.ParseHex(attachedImage.UUID)
			if err != nil {
				return nil, err
			}
			machine.HardDisks[index] = imageUUID
		}

		vbox.Machines[*machineUUID] = machine
	}

	return
}