testsetups_vm

#!/bin/bash

testsetup_vm_check() {
    testsetup_loop_vm 'Checking all created VMs and CTs'
}

testsetup_vm_getinfo() {
    testsetup_loop_vm 'Getting info on all created VMs and CTs'
}

testsetup_vm_findvm() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    echo 'Finding all created VMs and CTs'
    local arguments result
    for vmid in "${!vms[@]}"; do
        arguments="${vmnames[$vmid]}"
        runAction $target $arguments

        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_getnextvmid() {
    testsetup_simple
    local result=$? lines="${#lineoutput[*]}"

    (( result == 0 )) && {
        selectedid="${testoutput[$((lines-2))]}"
        echo "The new VMID from getnextid is: $selectedid"
    }

    return $result
}

testsetup_vm_clone() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    debugMessage 'Manual intervention needed'
    cat<<EOF
To which node should I attempt to clone VMs and CTs?
EOF
    promptNode "Enter node name (${nodes[0]}) " "${nodes[0]}" 1

    echo 'Cloning all created VMs and CTs'

    local flags arguments vmtype vmname name
    for vmid in "${!vms[@]}"; do
        vmtype="${vms[$vmid]}"

        # name for the clone
        vmname="test-clone${vmtype}${runcount}"
        name='name'; [[ "$vmtype" == "ct" ]] && name='hostname'

        echo 'Calling testsetup_vm_getnextvmid to get a new VMID for the clone'
        testsetup_vm_getnextvmid

        flags="-vmid ${selectedid}"
        arguments="${vmnames[$vmid]}"
        runAction $flags $target $arguments<<EOF
{
    "$name": "$vmname",
    "bwlimit": 0,
    "description": "testing $vmtype clone",
    "full": true,
    "target": "$selectednode"
}
EOF
 
        result=$?
        setActionResult $target $result
        (( result )) && break

        vms[$selectedid]="$vmtype"
        vmnames[$selectedid]="$vmname"
    done
 
    return $result
}

testsetup_vm_delete() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    local flags result olines
    for vmid in "${!vms[@]}"; do
        flags="-vmid ${vmid}"
        runAction $flags $target

        result=$?
        setActionResult $target $result
        (( result )) && break

        unset "vms[$vmid]"
        unset "vmnames[$vmid]"
        unset "vmconfigs[$vmid]"

        # set UPID for gettaskexitstatus
        olines=${#testoutput[*]}
        status="${testouput[$olines]}"
        [[ "${status##*: }" == "true" ]] && {
            UPIDs+=("$(sed -r 's/^.*\"(UPID[^"]+)".*$/\1/' <<< ${testoutput[$((olines-2))]})")
        }
    done
 
    return $result
}

testsetup_vm_getconfig() {
    testsetup_loop_vm 'Getting status of created VM/CTs'
}

testsetup_vm_getstatus() {
    testsetup_loop_vm 'Getting status of created VM/CTs'
}

testsetup_vm_setstatus() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    echo 'Cycling status for all created VMs/CTs'
    local flags arguments result
    for status in start reset suspend resume shutdown stop; do
        for vmid in "${!vms[@]}"; do
            case $status in
                @(reset|suspend)) [[ "${vms[$vmid]}" == "ct" ]] && continue ;;
                        shutdown) [[ "${vms[$vmid]}" == "vm" ]] && continue ;;
            esac

            flags="-vmid ${vmid}"
            arguments="$status"
            runAction $flags $target $arguments
            result=$?
            setActionResult $target $result
            (( result )) && break 2
        done
    done
 
    return $result
}

testsetup_vm_start() {
    testsetup_loop_vm 'Starting all created VM/CTs'
}

testsetup_vm_suspend() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    echo 'Suspending all created VMs'

    local flags
    for vmid in "${!vms[@]}"; do
        [[ "${vms[vmid]}" == "ct" ]] && continue

        flags="-vmid ${vmid}"
        runAction $flags $target
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_resume() {
    testsetup_loop_vm 'Resuming all created VMs'
}

testsetup_vm_reset() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    echo 'Resetting all created VMs'

    local flags
    for vmid in "${!vms[@]}"; do
        [[ "${vms[vmid]}" == "ct" ]] && continue

        flags="-vmid ${vmid}"
        runAction $flags $target
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_stop() {
    testsetup_loop_vm 'Stopping all created VM/CTs'
}

testsetup_vm_shutdown() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    echo 'Shutting down all created CTs'

    local flags
    for vmid in "${!vms[@]}"; do
        [[ "${vms[vmid]}" == "vm" ]] && continue

        flags="-vmid ${vmid}"
        runAction $flags $target
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_waitforshutdown() {
    testsetup_stub
}

testsetup_vm_migrate() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    nodes_bkp=("${nodes[@]}")
    selectednode_bkp=$selectednode

    for node in "${!nodes[@]}"; do
        [[ "${nodes[$node]}" == "$selectednode" ]] && unset -v 'nodes[$node]'
    done
    nodes=( "${nodes[@]}" )

    debugMessage 'Manual intervention needed'
    cat<<EOF
These nodes are available to test migration: ${nodes[@]}
To which node should I attempt to migrate VMs and CTs?
EOF
    promptNode "Enter node name (${nodes[0]}) " "${nodes[0]}" 1

    local flags arguments
    for vmid in "${!vms[@]}"; do
        flags="-vmid ${vmid}"
        arguments="$selectednode"
        runAction $flags $target $arguments<<EOF
{
    "bwlimit": 0,
    "online": true
}
EOF
        result=$?
        setActionResult $target $result
        (( result )) && break
    done

    nodes=("${nodes_bkp[@]}")
    selectednode=$selectednode_bkp
    return $result
}

testsetup_vm_getsnapshotlist() {
    testsetup_loop_vm 'Getting the list of snapshots for all created VM/CTs'
}

testsetup_vm_createsnapshot() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"
    local flags arguments result

    echo 'Taking a snapshot of all created VMs/CTs'
    for vmid in "${!vms[@]}"; do
        flags="-vmid ${vmid}"
        arguments="testsnapshot"
        runAction $flags $target $arguments<<EOF
{
    $([[ "${vms[$vmid]}" == "vm" ]] && echo '"vmstate": true,')
    "description": "test snapshot"
}
EOF
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_deletesnapshot() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"
    local flags arguments result

    echo 'Deleting snapshots of all created VMs/CTs'
    for vmid in "${!vms[@]}"; do
        flags="-vmid ${vmid}"
        arguments="testsnapshot"
        runAction $flags $target $arguments
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_rollback() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"
    local flags arguments result

    echo 'Rolling back all created VMs/CTs to "testsnapshot"'
    for vmid in "${!vms[@]}"; do
        flags="-vmid ${vmid}"
        arguments="testsnapshot"
        runAction $flags $target $arguments
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_createtemplate() {
    testsetup_loop_vm 'Creating a template of all created VMs and CTs'
}

testsetup_vm_createbackup() {
    local runcount=$1 ; shift
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"
    local flags result

    echo 'Backing up all created VMs/CTs'
    for vmid in "${!vms[@]}"; do
        flags="-vmid ${vmid}"
        runAction $flags $target<<EOF
{
    "compress": "gzip",
    "mode": "snapshot"
}
EOF
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
 
    return $result
}

testsetup_vm_movedisk() {
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    debugMessage 'Manual intervention needed'
    cat<<EOF
These are the storages I got from the previous storage_getstoragelist test: ${storages[@]}
To which storage should I attempt to move disks?
EOF

    promptStorage "Enter storage name (${storages[0]}) " "${storage[0]}" 1
    selectedstorage_ct=$selectedstorage
    selectedstorage_vm=$selectedstorage

    local result flags storage disk
    for vmid in "${!vms[@]}"; do
        storage="selectedstorage_${vms[$vmid]}"
        disk='"disk": "virtio0"'; [[ "${vms[$vmid]}" == "ct" ]] && disk='"volume": "rootfs"'

        flags="-vmid ${vmid}"
        runAction $flags $target<<EOF
{
    ${disk},
    "storage": "${!storage}",
    "delete": true
}
EOF
 
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
    return $result
}

testsetup_vm_resizedisk() {
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    local arguments flags result disk size
    for vmid in "${!vms[@]}"; do
        disk='virtio0'; [[ "${vms[$vmid]}" == "ct" ]] && disk='rootfs'
        size="$(( RANDOM % 4 + 1))G"
        
        echo "Attempting to resize disk '$disk' by $size"
        flags="-vmid ${vmid}"
        arguments="$disk +$size"
        runAction $flags $target $arguments
        result=$?
        setActionResult $target $result
        (( result )) && break
    done
    return $result
}


testsetup_vm_getspiceproxy() {
    testsetup_loop_vm
}

testsetup_vm_monitorcmd() {
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    cat<<EOF
For this test please enter lines with Qemu monitor commands to send to all created VMs
An empty line ends the test
EOF

    local command
    while read -p 'Enter monitor command (empty line to end the test): ' command; do
        [[ -z "$command" ]] && break
        echo "Sending the command '$command' to all created VMs"

        local arguments flags result
        for vmid in "${!vms[@]}"; do
            [[ "${vms[$vmid]}" == "ct" ]] && continue
            echo "Watch the VM $vmid (${vmnames[$vmid]}) and verify that the commands are affecting it"

            flags="-vmid ${vmid}"
            arguments="$command"

            runAction $flags $target $arguments
            result=$?
            setActionResult $target $result
            (( result )) && break 2
        done
    done
    return $result
}

testsetup_vm_sendkeysstring() {
    local target=${FUNCNAME##*${setup_prefix}} ; debugMessage "SETUP TARGET: $target"

    cat<<EOF
For this test please enter lines with strings to be sent to all created VMs
An empty line ends the test
EOF


    local line
    while read -p 'Enter string (empty line to end the test): ' line; do
        [[ -z "$line" ]] && break
        echo "Sending the line '$line' to all created VMs"

        local arguments flags result
        for vmid in "${!vms[@]}"; do
            [[ "${vms[$vmid]}" == "ct" ]] && continue
            echo "Open the console for the VM $vmid (${vmnames[$vmid]}) and verify that the strings are appearing on the console"

            flags="-vmid ${vmid}"
            arguments="\"$line\""

            runAction $flags $target $arguments
            result=$?
            setActionResult $target $result
            (( result )) && break 2
        done
    done
    return $result
}

testsetup_vm_sshforwardusernet() {
    testsetup_loop_vm 'Setting SSH forward for all created VM/CTs'
}

testsetup_vm_removesshforwardusernet() {
    testsetup_loop_vm 'Removing SSH forward for all created VM/CTs'
}

testsetup_vm_getagentnetworkinterfaces() {
    testsetup_stub
}