Ejemplo n.º 1
0
func UiVmConfig(ui *gui.DialogUi, driver deployer.HostinfoDriver, xidata *xmlinput.XMLInputData,
	pathToMainImage string, sconf *image.Storage, conf *guest.Config) error {
	var installedRamMb int
	var maxRAM int
	var err error

	list := make([]string, 0)
	index := 1

	if xidata.CPU.Configure {
		cpuStr := fmt.Sprintf("  %-9s |  %d-%d", "CPU", xidata.CPU.Min, xidata.CPU.Max)
		list = []string{cpuStr, strconv.Itoa(index), "1", strconv.Itoa(xidata.CPU.Default), "1", "30", "6", "0", "0"}
		index++
	} else if xidata.CPU.Default > 0 {
		conf.CPUs = xidata.CPU.Default
	}
	if xidata.RAM.Configure {
		installedRamMb, err = driver.RAMSize()
		if err != nil {
			return utils.FormatError(err)
		}
		if xidata.RAM.Max > installedRamMb || xidata.RAM.Max == xmlinput.UnlimitedAlloc {
			maxRAM = installedRamMb
		} else {
			maxRAM = xidata.RAM.Max
		}

		ramStr := fmt.Sprintf("  %-9s |  %d-%dG", "RAM", xidata.RAM.Min/1024, maxRAM/1024)
		list = append(list, []string{ramStr, strconv.Itoa(index), "1", strconv.Itoa(xidata.RAM.Default / 1024), "2", "30", "6", "0", "0"}...)
		index++
	} else if xidata.RAM.Default > 0 {
		conf.RamMb = xidata.RAM.Default
	}
	if xidata.Disks.Configure {
		diskName := "Disk"
		for i, disk := range xidata.Disks.Configs {
			if i > 0 {
				diskName = strconv.Itoa(i) + "_" + strconv.Itoa(i)
			}
			diskStr := fmt.Sprintf("  %-9s |  %d-%dG", diskName, disk.Min/1024, disk.Max/1024)
			indexStr := strconv.Itoa(index)
			list = append(list, []string{diskStr, indexStr, "1", strconv.Itoa(disk.Default / 1024), indexStr, "30", "6", "0", "0"}...)
			index++
		}
	}
	str := " ______________________________________\n|	 Resource	 |		Maximum		|		Allocated		|"
	installedCpus, err := driver.CPUs()
	if err != nil {
		return utils.FormatError(err)
	}

	index--

	if index > 1 {

	MainLoop:
		for {
			ui.SetSize(11, 46)
			ui.SetTitle("Virtual Machine configuration")
			ui.HelpButton(true)
			ui.SetHelpLabel("Back")
			resultIndex := 0
			result, err := ui.Mixedform(str, false, list[0:]...)
			if err != nil {
				return err
			}
			if len(result) < index {
				continue
			}
			if xidata.CPU.Configure {
				selectedCpus, err := strconv.Atoi(result[resultIndex])
				if err != nil {
					continue
				}
				if uiCpuNotOK(ui, selectedCpus, installedCpus, xidata.CPU.Min, xidata.CPU.Max) {
					continue
				}
				conf.CPUs = selectedCpus
				resultIndex++
			}
			if xidata.RAM.Configure {
				selectedRamMb, err := utils.FloatStringToInt(result[resultIndex], 1024)
				if err != nil {
					continue MainLoop
				}
				if uiRamNotOK(ui, selectedRamMb, installedRamMb, xidata.RAM.Min, maxRAM) {
					continue
				}
				conf.RamMb = selectedRamMb
				resultIndex++
			}
			if xidata.Disks.Configure {
				disks := make([]int, 0)
				for _, disk := range xidata.Disks.Configs {
					selectedDiskSizeMb, err := utils.FloatStringToInt(result[resultIndex], 1024)
					if err != nil {
						continue MainLoop
					}
					if uiDiskNotOK(ui, selectedDiskSizeMb, disk.Min, disk.Max) {
						continue MainLoop
					}
					disks = append(disks, selectedDiskSizeMb*1024)
					resultIndex++
				}
				if conf.Storage, err = config.StorageConfig(pathToMainImage, 0, sconf, disks); err != nil {
					return err
				}
			}
			break
		}
	}
	return nil
}
Ejemplo n.º 2
0
func UiNUMATopology(ui *gui.DialogUi, c *guest.Config, d deployer.EnvDriver, totalCpusOnHost int) (bool, error) {
	var list []string

	// file, err := os.Create("/tmp/UiNUMATopology.txt")
	// if err != nil {
	// 	return false, nil
	// }
	// defer file.Close()

	isChanged := false
	hCPUnotOnce := ""
	CheckIfCPUdoubleUsed := true

MainLoop:
	for {
		// file.WriteString("[UiNUMATopology] MainLoop: \n")
		list = make([]string, 0)
		tempData := make(map[int]map[int]string)
		// file.WriteString("[UiNUMATopology] totalCpusOnHost: " + strconv.Itoa(totalCpusOnHost) + " \n")
		for _, n := range c.NUMAs {
			// file.WriteString("[UiNUMATopology] c.NUMAs\n")
			// file.WriteString("[UiNUMATopology] len(n.CPUPin): " + strconv.Itoa(len(n.CPUPin)) + "\n")
			keys := make([]int, 0)
			for vcpu, _ := range n.CPUPin {
				keys = append(keys, vcpu)
				// file.WriteString("[UiNUMATopology] vcpu: " + strconv.Itoa(vcpu) + "\n")
			}

			sort.Ints(keys)
			var hostCpu string
			for _, k := range keys {
				if len(n.CPUPin[k]) > 1 {
					if len(n.CPUPin[k]) == totalCpusOnHost {
						CheckIfCPUdoubleUsed = false
						hostCpu = "0-" + strconv.Itoa(totalCpusOnHost-1)
					} else {
						var tmpStrSlice []string
						for _, c := range n.CPUPin[k] {
							tmpStrSlice = append(tmpStrSlice, strconv.Itoa(c))
						}
						hostCpu = strings.Join(tmpStrSlice, ",")
					}
				} else {
					hostCpu = strconv.Itoa(n.CPUPin[k][0])
				}
				// file.WriteString("[UiNUMATopology] hostCpu: " + hostCpu + "\n")
				tempData[k] = make(map[int]string)
				tempData[k][n.CellID] = hostCpu

				// file.WriteString("tempData[" + strconv.Itoa(k) + "][" + strconv.Itoa(n.CellID) + "] = " + hostCpu + "  \n")
			}
		}

		// we need to represent sorted vCPU IDs and not vNUMA IDs
		keys := make([]int, 0)
		for k, _ := range tempData {
			keys = append(keys, k)
		}

		duplicate_frequency := make(map[string]int)
		sort.Ints(keys)
		for _, key := range keys {
			for k, v := range tempData[key] {
				list = append(list, strconv.Itoa(key), fmt.Sprintf("%-10s%-18d%-7s", " ", k, v))
				temphCPU := v
				_, exist := duplicate_frequency[temphCPU]
				if exist {
					duplicate_frequency[temphCPU] += 1 // increase counter by 1 if already in the map
				} else {
					duplicate_frequency[temphCPU] = 1 // else start counting from 1
				}
				// file.WriteString("k: " + strconv.Itoa(k) + " v: " + v + "  \n")
			}
		}

		hCPUnotOnce = ""
		for k_dup, v_dup := range duplicate_frequency {
			if v_dup > 1 {
				hCPUnotOnce = k_dup
				break
			}
		}

		ui.SetLabel(uiNUMATopologyHeader(ui, c))
		result, err := ui.Menu(len(list), list[0:]...)
		// file.WriteString("[UiNUMATopology] result: " + result + " err: " + err.Error() + " len(list): " + strconv.Itoa(len(list)) + " \n")

		if err == nil {
			if hCPUnotOnce != "" && isChanged && CheckIfCPUdoubleUsed {
				ui.Output(gui.Warning, "CPU "+hCPUnotOnce+" is assigned to more than one vCPU")
				continue
			}
			break
		}
		if err.Error() != gui.DialogNext {
			// file.WriteString("[UiNUMATopology] err.Error() != gui.DialogNext " + err.Error() + " \n")
			return isChanged, err
		}

	InternalLoop:
		for {
			// file.WriteString("[UiNUMATopology] InternalLoop: \n")

			ui.SetTitle("VA vCPU Configuration")
			ui.SetExtraLabel("Help")
			// file.WriteString("result: (" + result + ") \n")
			resultInt, err := strconv.Atoi(result)
			if err != nil {
				// file.WriteString("[UiNUMATopology] strconv.Atoi(result) " + err.Error() + "\n")
				return isChanged, err
			}

			var vnumaStr string
			var cpusStr string
			tempDataLen := len(tempData)
			for k, v := range tempData[resultInt] {
				vnumaStr = strconv.Itoa(k)
				cpusStr = v
				// tempDataLen++
			}
			// file.WriteString("resultInt: (" + result + ") \n")
			// DE11527
			index := resultInt
			resultInt--

			// var vnumaPredecStr string
			// for k, _ := range tempData[resultInt] {
			// 	vnumaPredecStr = strconv.Itoa(k)
			// 	// file.WriteString("vnumaPredecStr: (" + vnumaPredecStr + ") ")
			// }

			var lst []string
			label := "Set affinity for vCPU " + result

			var vnumaMinus1 string
			var vnumaPlus1 string
			var vnumaIndex string
			var vnumaTemp string
			if tempDataLen > 3 {
				if index > (tempDataLen - 1) {
					index = index - tempDataLen
				}

				indexMinus1 := index - 1

				if indexMinus1 < 0 {
					indexMinus1 = tempDataLen + indexMinus1
				}
				indexPlus1 := index + 1

				if indexPlus1 > tempDataLen {
					indexPlus1 = indexPlus1 - tempDataLen
				}

				for k, _ := range tempData[indexMinus1] {
					vnumaMinus1 = strconv.Itoa(k)
				}

				for k, _ := range tempData[indexPlus1] {
					vnumaPlus1 = strconv.Itoa(k)
				}
				for k, _ := range tempData[index] {
					vnumaIndex = strconv.Itoa(k)
				}

				if index == (tempDataLen - 1) {
					// vnumaPlus1 = vnumaIndex

					for k, _ := range tempData[0] {
						vnumaTemp = strconv.Itoa(k)
					}
					if vnumaTemp != vnumaIndex {
						vnumaPlus1 = vnumaIndex
					} else {
						vnumaPlus1 = "vnumaPlus1"
					}

				}
				if index == 0 {
					// vnumaMinus1 = vnumaIndex
					for k, _ := range tempData[tempDataLen-1] {
						vnumaTemp = strconv.Itoa(k)
					}
					if vnumaTemp != vnumaIndex {
						vnumaMinus1 = vnumaIndex
					} else {
						vnumaMinus1 = "vnumaIndex"
					}
				}
			} else {
				vnumaMinus1 = "-1"
				vnumaPlus1 = "+1"
			}

			// xxxxxx := d.Id()
			// file.WriteString("d.Id(): (" + xxxxxx + ") ")
			// file.WriteString("vnumaStr: (" + vnumaStr + ") vnumaPredecStr: (" + vnumaPredecStr + ") \n")
			// file.WriteString("indexMinus1: (" + strconv.Itoa(indexMinus1) + ") index: (" + strconv.Itoa(index) + ")  indexPlus1: (" + strconv.Itoa(indexPlus1) + ")\n")
			// file.WriteString("vnumaMinus1: (" + vnumaMinus1 + ") vnumaPlus1: (" + vnumaPlus1 + ") \n")
			// file.WriteString("tempDataLen: (" + strconv.Itoa(tempDataLen) + ")  \n")
			// if vnumaStr == vnumaPredecStr && d.Id() == "QEMU-Libvirt" {
			if vnumaMinus1 == vnumaPlus1 && d.Id() == "QEMU-Libvirt" {
				lst = []string{"VA vNUMA ID : ", "1", "1", vnumaStr, "1", "15", "2", "0", "2"}
				label += "\n\nIMPORTANT! Some QEMU versions do not support\n" +
					"disjoint NUMA CPU ranges therefore vNUMA configuration\n" +
					"is disabled for this vCPU.\n"
			} else {
				lst = []string{"VA vNUMA ID : ", "1", "1", vnumaStr, "1", "15", "2", "0", "0"}
			}

			lst = append(lst, "Host CPU(s) : ", "2", "1", cpusStr, "2", "15", "30", "0", "0")
			r, err := ui.Mixedform(label, false, lst[0:]...)
			if err != nil {
				if err.Error() == gui.DialogNext {
					uiShowNumaTopologyHelpMsg(ui)
					continue
				}
				return isChanged, err
			}
			if len(r) < 2 {
				continue
			}

			vcpuInt, err := strconv.Atoi(result)
			if err != nil {
				continue
			}

			vnumaInt, err := strconv.Atoi(r[0])
			if err != nil {
				ui.Output(gui.Warning, "Illegal input \""+r[0]+"\"", "Press <OK> to return to menu.")
				continue
			}
			if err := verifyRange(vnumaInt, len(c.NUMAs)); err != nil {
				ui.Output(gui.Warning, err.Error(), "Press <OK> to return to menu.")
				continue
			}

			hostCpus := r[1]
			cpus := make([]int, 0)
			if strings.Contains(hostCpus, ",") {
				for _, e := range strings.Split(hostCpus, ",") {
					if strings.Contains(e, "-") {
						cpus, err = splitByHypen(e, totalCpusOnHost)
						if err != nil {
							ui.Output(gui.Warning, err.Error(), "Press <OK> to return to menu.")
							continue InternalLoop
						}
					} else {
						cpu, err := strconv.Atoi(e)
						if err != nil {
							ui.Output(gui.Warning, "Illegal input \""+e+"\"", "Press <OK> to return to menu.")
							continue InternalLoop
						}
						if err := verifyRange(cpu, totalCpusOnHost); err != nil {
							ui.Output(gui.Warning, err.Error(), "Press <OK> to return to menu.")
							continue InternalLoop
						}
						cpus = append(cpus, cpu)
					}
				}
			} else if strings.Contains(hostCpus, "-") {
				cpus, err = splitByHypen(hostCpus, totalCpusOnHost)
				if err != nil {
					ui.Output(gui.Warning, err.Error(), "Press <OK> to return to menu.")
					continue
				}
			} else {
				cpu, err := strconv.Atoi(hostCpus)
				if err != nil {
					ui.Output(gui.Warning, "Illegal input \""+hostCpus+"\"", "Press <OK> to return to menu.")
					continue
				}
				if err := verifyRange(cpu, totalCpusOnHost); err != nil {
					ui.Output(gui.Warning, err.Error(), "Press <OK> to return to menu.")
					continue
				}
				cpus = append(cpus, cpu)
			}

			// delete the old entry
			isChanged = true
			for _, n := range c.NUMAs {
				for vcpu, _ := range n.CPUPin {
					if vcpu == vcpuInt {
						delete(n.CPUPin, vcpu)
					}
				}
			}

			sort.Ints(cpus)
			// set the new entry
			c.NUMAs[vnumaInt].CPUPin[vcpuInt] = cpus
			continue MainLoop
		}
		break
	}

	// ui.Output(gui.Warning, "CPU "+hCPUnotOnce+" is assigned to more than one vCPU")

	// if isChanged {
	// 	file.WriteString("isChanged\n")
	// } else {
	// 	file.WriteString("NotChanged\n")
	// }
	// if isChanged {
	// 	ui.Output(gui.Warning, "CPU j is assigned to more than one vCPU")
	// 	continue MainLoop
	// }
	// file.WriteString("return: \n")
	return isChanged, nil
}
Ejemplo n.º 3
0
func UiSshConfig(ui *gui.DialogUi) (*sshconf.Config, error) {
	cfg := new(sshconf.Config)
	cfg.Port = "22"
	cfg.User = "******"
	origlist := []string{"IP      : ", "1", "1", "", "1", "10", "22", "0", "0",
		"SSH Port: ", "2", "1", cfg.Port, "2", "10", "22", "0", "0",
		"Username: "******"3", "1", cfg.User, "3", "10", "22", "0", "0"}

MainLoop:
	for {
		ui.HelpButton(true)
		ui.SetHelpLabel("Back")
		reslist, err := ui.Mixedform("Remote session configuration", false, origlist[0:]...)
		if err != nil {
			return nil, err
		}
		if len(reslist) < 3 {
			continue
		}
		if net.ParseIP(reslist[0]) == nil {
			continue
		}
		cfg.Host = reslist[0]

		portDig, err := strconv.Atoi(reslist[1])
		if err != nil {
			return nil, utils.FormatError(err)
		}
		if portDig > 65535 {
			continue
		}

	AuthLoop:
		for {
			ui.SetTitle("Authentication method")
			ui.SetSize(9, 18)
			ui.HelpButton(true)
			ui.SetHelpLabel("Back")
			val, err := ui.Menu(2, "1", "Password", "2", "Private key")
			if err != nil {
				switch err.Error() {
				case gui.DialogMoveBack:
					continue MainLoop
				case gui.DialogExit:
					os.Exit(1)
				}
			}

			switch val {
			case "1":
				cfg.Password, err = ui.GetPasswordFromInput(cfg.Host, cfg.User, "Back", "", false)
			case "2":
				cfg.PrvtKeyFile, err = ui.GetPathToFileFromInput("Path to ssh private key file", "Back", "")
			}
			if err != nil {
				switch err.Error() {
				case gui.DialogMoveBack:
					continue AuthLoop
				case gui.DialogExit:
					os.Exit(1)
				}
			}
			break MainLoop
		}
	}

	run := utils.RunFunc(cfg)
	errCh := make(chan error)
	defer close(errCh)
	go func() {
		// verifying that user is able execute a command by using sudo
		_, err := run("uname")
		errCh <- err
	}()

	if err := ui.Wait("Trying to establish SSH connection to remote host.\nPlease wait...", time.Second*1, time.Second*5, errCh); err != nil {
		ui.Output(gui.Warning, "Unable to establish SSH connection.", "Press <OK> to return to menu.")
		goto MainLoop
	}
	return cfg, nil
}