vmEdit.go

package cmdVM

import (
    "strconv"
    "strings"
    "errors"
    "nexus-common/vm"
    "nexus-common/params"
    u "nexus-client/utils"
    g "nexus-client/globals"
)

type Edit struct {
    Name string
}

func (cmd *Edit)GetName() string {
    return cmd.Name
}

func (cmd *Edit)GetDesc() []string {
    return []string{
        "Edits one or more VMs' properties: name, cpus, ram or nic.",
        "If not the VM's owner: requires VM_EDIT VM access capability or VM_EDIT_ANY user capability."}
}

func (cmd *Edit)PrintUsage() {
    for _, desc := range cmd.GetDesc() {
        u.PrintlnErr(desc)
    }
    u.PrintlnErr("―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――")
    u.PrintlnErr("USAGE: "+cmd.GetName()+" [ID ...] [regex ...] [name=...] [cpus=...] [ram=...] [nic=...] [usb=...]")
    u.PrintlnErr("―――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――――")
    const usage string = `Parameters that can be changed (at least one must be specified):
name    Name of the VM.
cpus    Number of CPUs, between 1 and 16.
ram     Amount of RAM in MB, between 256 and 32768.
nic     Network interface, either "none" (no network) or "user" (network access).
usb     List of USB devices exposed in the VM; either "none" or a list of comma separated
        vendorID:productID (4-digit hex number), each specifying a USB device; example
        exposing two USB devices: 1fc9:001d,067b:2303`
    u.PrintlnErr(usage)
    u.PrintlnErr("")
    printRegexUsageDetails()
}

func (cmd *Edit)Run(args []string) int {
    client := g.GetInstance().Client
    host := g.GetInstance().Host

    argc := len(args)
    if argc < 1 {
        cmd.PrintUsage()
        return 1
    }

    vmParams, patterns, err := cmd.parseArgs(args)
    if err != nil {
        u.PrintlnErr(err.Error())
        return 1
    }

    if vmParams == nil {
        cmd.PrintUsage()
        return 1
    }

    vms, err := getFilteredVMs("/vms/edit", patterns)
    if err != nil {
        u.PrintlnErr(err.Error())
        return 1
    }

    if len(vms) == 0 {
        u.PrintlnErr("Error: VM(s) not found.")
        return 1
    }

    statusCode := 0

    for _, vm := range(vms) {
        uuid := vm.ID.String()
        resp, err := client.R().SetBody(vmParams).Put(host+"/vms/"+uuid)
        if err != nil {
            u.PrintlnErr("Failed editing VM \""+vm.Name+"\": "+err.Error())
            statusCode = 1
        } else {
            if resp.IsSuccess() {
                u.Println("Successfully edited VM \""+vm.ID.String()+"\":")
                u.Println(resp.String())
            } else {
                u.PrintlnErr("Failed editing VM \""+vm.Name+"\": "+resp.Status()+": "+resp.String())
                statusCode = 1
            }
        }
    }

    return statusCode
}

func (cmd *Edit)parseArgs(args []string) (*params.VMEdit, []string, error) {
    vmParams := &params.VMEdit { Cpus: 0, Ram: 0 }
    var patterns []string
    atLeastOneArg := false

    getStringVal := func(s string, prefix string) string {
        if strings.HasPrefix(s, prefix) {
            parts := strings.Split(s, prefix)
            return parts[1]
        }
        return ""
    }

    for _, arg := range args {
        s := getStringVal(arg, "name=")
        if s != "" {
            vmParams.Name = s
            atLeastOneArg = true
            continue
        }
        s = getStringVal(arg, "cpus=")
        if s != "" {
            cpus, err := strconv.Atoi(s)
            if err != nil || cpus < 1 {
                return nil, nil, errors.New("Error: invalid number of CPU(s)!")
            }
            vmParams.Cpus = cpus
            atLeastOneArg = true
            continue
        }
        s = getStringVal(arg, "ram=")
        if s != "" {
            ram, err := strconv.Atoi(s)
            if err != nil || ram < 1 {
                return nil, nil, errors.New("Error: invalid amount of RAM!")
            }
            vmParams.Ram = ram
            atLeastOneArg = true
            continue
        }
        s = getStringVal(arg, "nic=")
        if s != "" {
            vmParams.Nic = vm.NicType(s)
            atLeastOneArg = true
            continue
        }
        s = getStringVal(arg, "usb=")
        if s != "" {
            vmParams.UsbDevs = u.Str2UsbDevices(s)
            atLeastOneArg = true
            continue
        }

        patterns = append(patterns, arg)
    }

    if atLeastOneArg {
        return vmParams, patterns, nil
    } else {
        return nil, nil, nil
    }
}