LinuxQuestions.org - [SOLVED] GUI frontend for QEMU

years ago I wrote this script; I still use it...

Code:

#!/bin/ksh



# ksh is more or less required due to scoping of variables

# bash is picky and doesn't scope outside piped loops :-(



machine=${1}

inifile="${HOME}/bin/manage_vm.ini"



parse_inifile()

{

        if [ "${machine}" = "list"  ]

        then

                cat ${inifile} | grep -v "^#" | grep -e "^\[.*\]$" | cut -d '[' -f 2 - | cut -d ']' -f 1

                return

        fi



        section_start=`cat ${inifile} | grep -v "^#" | grep -n "^\[${machine}\]$" | cut -d ':' -f 1`



        if [ -z "${section_start}" ]

        then

                echo "No [${machine}] section found; valid sections are: "

                cat ${inifile} | grep -v "^#" | grep -e "^\[.*\]$" | cut -d '[' -f 2 - | cut -d ']' -f 1

                exit

        fi



        section_end=`cat ${inifile} | grep -v "^#" | grep -e "^$" -n | cut -d ':' -f 1 | while read num

        do

                if [ ${num} -gt ${section_start} ]

                then

                        echo ${num}

                fi

        done | head -n 1`



        ((diff=section_end - section_start))

                                                                                                                                                                                                                                            

        echo "Start: ${section_start}"                                                                                                                                                                                                      

        echo "End  : ${section_end}"                                                                                                                                                                                                        

        echo "Diff : ${diff}"                                                                                                                                                                                                                

        cat ${inifile} | grep -v "^#" | tail -n +${section_start} | head -n ${diff} | while read option                                                                                                                                      

        do                                                                                                                                                                                                                                  

                echo "${#OPT[*]}: ${option}"                                                                                                                                                                                                

                OPT[${#OPT[*]}]=${option}                                                                                                                                                                                                    

        done                                                                                                                                                                                                                                

}                                                                                                                                                                                                                                            

                                                                                                                                                                                                                                            

parse_options()                                                                                                                                                                                                                              

{                                                                                                                                                                                                                                            

        COUNT=0                                                                                                                                                                                                                              

        PARAMETERS=""                                                                                                                                                                                                                        

        QEMU_BIN=/usr/bin/qemu-system-x86_64                                                                                                                                                                                                

        QEMU_AUDIO_DRV=sdl                                                                                                                                                                                                                  

        export SDL_AUDIODRIVER=alsa                                                                                                                                                                                                          

                                                                                                                                                                                                                                            

        while [ ${COUNT} -lt ${#OPT[*]} ]                                                                                                                                                                                                    

        do                                                                                                                                                                                                                                  

                ((COUNT+=1)) # we can safely do this; as OPT[0] is the section header                                                                                                                                                        

                ARG=`echo ${OPT[${COUNT}]} | cut -d '=' -f 1`                                                                                                                                                                                

                VAL=`echo ${OPT[${COUNT}]} | cut -d '=' -f 2-`                                                                                                                                                                              

                                                                                                                                                                                                                                            

                case ${ARG} in                                                                                                                                                                                                              

                        "")                                                                                                                                                                                                                  

                                echo "${machine} parsed."                                                                                                                                                                                    

                                ;; # yes pretty silly, right?                                                                                                                                                                                

                        "qemu_bin") # with qemu_bin you can configure another qemu binary                                                                                                                                                    

                                QEMU_BIN="${VAL}"                                                                                                                                                                                            

                                ;;                                                                                                                                                                                                          

                        "machine")                                                                                                                                                                                                          

                                PARAMETERS="${PARAMETERS}-M ${VAL} "                                                                                                                                                                        

                                ;;                                                                                                                                                                                                          

                        *)

                                PARAMETERS="${PARAMETERS} -${ARG} ${VAL} "

                                ;;

                esac

        done

        echo ${PARAMETERS}

}



main()

{

        parse_inifile

        parse_options



        case $1 in

                "stop")

                        echo "Not implemented yet."

                        ;;

                "start")

                        ${QEMU_BIN} ${PARAMETERS}

                        ;;

        esac

}



if [ -z "${1}" ]

then

        PS3="Choose: "

        select choice in `$0 list` quit

        do

                if [ "${choice}" = "quit" ]

                then

                        return 0

                else

                        $0 $choice start

                fi

        done

#      echo "Usage: $0 <machine|"list"> <stop|start|restart|status>"

#      return 1

fi



if [ "${1}" = "list" ]

then

        main list

        return 0

fi



if [ -z "${2}" ]

then

        echo "Usage: $0 <machine|"list"> <stop|start|restart|status|prepare_listen>"

        return 1

fi



case ${2} in

        "stop")

                echo "Not implemented yet."

                ;;

        "start")

                main start

                ;;

        "prepare_listen")

                echo "Not implemented yet."

                ;;

        "status")

                echo "Not implemented yet."

                ;;

        "restart")

                echo "Not implemented yet."

                ;;

        *)

                echo "Invalid action: actions are: stop, start, restart or status"

                ;;

esac

The ini file it uses has entries that look like this:

Code:



[broker1]

qemu_bin=/usr/bin/qemu-system-x86_64

monitor=stdio

smp=4,cores=2,sockets=2

vga=vmware

cpu=qemu64

m=4096

balloon=virtio

localtime=

drive=file=/qcow/broker1.qcow2,if=virtio

drive=file=/qcow/broker1-data.qcow2,if=virtio

cdrom=/qcow/iso/Slackware/slackware64-14.1-install-dvd.iso

boot=once=cd,menu=on

net=nic,vlan=0,macaddr=52:54:00:e7:91:b4,model=virtio

net=vde,vlan=0

name="broker1"

enable-kvm=



[broker2]

qemu_bin=/usr/bin/qemu-system-x86_64

monitor=stdio

smp=6,cores=2,sockets=3

vga=vmware

cpu=qemu64

m=4096

balloon=virtio

localtime=

drive=file=/qcow/broker2.qcow2,if=virtio

drive=file=/qcow/broker2-data.qcow2,if=virtio

cdrom=/qcow/iso/Slackware/slackware64-14.1-install-dvd.iso

boot=once=cd,menu=on

net=nic,vlan=0,macaddr=52:54:00:e7:91:b5,model=virtio

net=vde,vlan=0

name="broker2"

enable-kvm=

every ini field has a direct mapping to the qemu-command... have to admit that I wrote this script because virsh/virt-manager didn't have the options added yet that qemu had and that I wanted to use :-)