#!/bin/bash
# -----------------------------------------------------------------------------
# Copyright (c) 2007..2010 - RZ Uni FR
# Copyright (c) 2007..2011 - OpenSLX GmbH
#
# This program is free software distributed under the GPL version 2.
# See http://openslx.org/COPYING
#
# If you have any feedback please consult http://openslx.org/feedback and
# send your suggestions, praise, or complaints to feedback@openslx.org
#
# General information about OpenSLX can be found at http://openslx.org/
# -----------------------------------------------------------------------------
# run-virt.sh
#    - This is the generic wrapper for the several virtualization solutions.
#      The idea is to setup a set of variables used by at least two different
#      tools and then include the specific plugin which configures the speci-
#      fied virtualization tool.
################################################################################

. /etc/opt/openslx/openslx.conf

################################################################################
### Define default dirs / get configs
################################################################################

PLUGINCONFROOT=${OPENSLX_DEFAULT_CONFDIR}/plugins
PLUGINCONFDIR=${PLUGINCONFROOT}/vmchooser
# include general configuration from vmchooser
[ -f ${PLUGINCONFROOT}/vmchooser/vmchooser.conf ] && \
  . ${PLUGINCONFROOT}/vmchooser/vmchooser.conf
# load general virtualization information
[ -f ${PLUGINCONFROOT}/virtualization/virtualization.conf ] && \
  . ${PLUGINCONFROOT}/virtualization/virtualization.conf

################################################################################
### Functions used throughout the script
################################################################################

# function to write to stdout and logfile
LOGFILE=${OPENSLX_DEFAULT_LOGDIR}/run-virt.${USER}.$$.log
writelog () {
  # write to stdout
  echo -e "$1"
  # log into file
  echo -e "$1" >> ${LOGFILE}
}

# remove config dirs when exit
cleanexit () {
  if echo "${RMDIRS}" 2>/dev/null | grep -q ${xmlvirt}; then
    writelog "${xmlvirt} exited. Cleanning up... \c"
    rm -rf ${RMDIRS} >/dev/null 2>&1
    writelog "done"
  fi

  exit "$1"
}

# check for important files used
filecheck ()
{
  filecheck=$(LANG=us ls -lh ${diskfile} 2>&1)
  writelog "Filecheck:\n${filecheck}\n"
  noimage=$(echo ${filecheck} | grep -i "no such file or directory" | wc -l)
  rightsfile=${diskfile}

  # check if link
  if [ -L "${diskfile}" ]; then
    # take link target
    rightsfile=$(ls -lh ${diskfile} 2>&1 | awk -F '-> *' '{print $2}')
    rightsfile=${vmdir}/${rightsfile}
    filecheck=$(LANG=us ls -lh ${rightsfile} 2>&1)
  fi

  # does file exist
  if [ "${noimage}" -ge "1" ]; then
    writelog "Virtual Machine Image Problem:\c "
    writelog "\tThe image you've specified doesn't exist."
    writelog "Filecheck says:\c "
    writelog "\t\t${diskfile}:\n\t\t\tNo such file or directory"
    writelog "Hint:\c "
    writelog "\t\t\tCompare spelling of the image with your options.\n"
    exit 1
  fi

  # readable by calling user
  if ! [ -r "${diskfile}" >/dev/null 2>&1 \
    -o -r "${diskfile}" >/dev/null 2>&1 ]; then
    writelog "Vmware Image Problem:\c "
    writelog "\tThe image you've specified has wrong rights."
    writelog "Filecheck says:\t\t$(echo ${filecheck} \
      | awk '{print $1" "$3" "$4}') ${rightsfile}"
    writelog "Hint:\t\t\tChange rights with: chmod a+r ${rightsfile}\n"
    exit 1
  fi

  # writable (for persistent-mode)?
  if ! [ -w "${diskfile}" >/dev/null 2>&1 \
    -o -w "${diskfile}" >/dev/null 2>&1 ] \
    && [ "${np}" = "independent-persistent" ]; then
    writelog "Vmware Image Problem:\c "
    writelog "\tThe image you have specified has wrong rights."
    writelog "Filecheck says:\t\t$(echo ${filecheck} \
      | awk '{print $1" "$3" "$4}') ${rightsfile}"
    writelog "Hint:\t\t\tUse nonpersistent-mode or change rights to rw\n"
    exit 1
  fi
}

################################################################################
### Get XML file and dir
################################################################################

# absolute or relative path?
xmlfile=$1
if ls ${xmlfile} 2>/dev/null | grep '/' >/dev/null 2>&1; then
  xmlpath=$(dirname ${xmlfile})
  xmlfile=$(basename ${xmlfile})
else
  xmlpath=${vmchooser_xmlpath}
fi
# full path
xmlfile="${xmlpath}/${xmlfile%.xml}.xml"

################################################################################
### Sanity checks
################################################################################

# test if the xml file is valid
if ! [ -r "${xmlfile}" ]; then
  writelog "${xmlfile} not a readable XML file!"
  exit 1
fi

# test if XML file
if ! grep '<?xml' "${xmlfile}" >/dev/null 2>&1; then
  writelog \
    "Submitted configuration file ${xmlfile} seems to have wrong XML format"
  exit 1
fi

# check for running in graphical environment otherwise no much use here
[ -z "$DISPLAY" ] && echo -e "\n\tStart only within a graphical desktop!\n" \
  && exit 1

################################################################################
###  Logo for console
################################################################################

cat <<EOL
                                             __        __   
                .----.--.--.-----.___.--.--.|__|.----.|  |_ 
                |   _|  |  |     |___|  |  ||  ||   _||   _|
                |__| |_____|__|__|    \___/ |__||__|  |____|
          OpenSLX virtual machine environment preparation script ...

EOL

################################################################################
### Read needed variables from XML file
################################################################################

writelog "Starting configuration..."
writelog "\tLogfile:\t\t${LOGFILE}"
writelog "\t/tmp info:\t\t$(df -h | grep " /tmp$" | awk '{print $2}') \c"
writelog "$(grep "/tmp " /proc/mounts | awk '{print $1" "$2" "$3" "$4}')"
writelog "\tVM XML dir:\t\t$(dirname ${xmlfile})"
writelog "\tXML file:\t\t${xmlfile}"
writelog "VM config:"

# Name of the virt image
imgname=$(grep -io '<image_name param=.*"' ${xmlfile} \
          | sed -e "s/&.*;/; /g" | awk -F '"' '{ print $2 }')

# Imagename /w full path
if echo ${imgname} 2>/dev/null | grep -q '^/' >/dev/null 2>&1; then
  imgpath=$(dirname ${imgname})
  imgname=$(basename ${imgname})
  vmpath=${imgpath}/${imgname}
# If old vmchooser binary stuff
# We do not need folder name as it is already included by vmchooser
elif echo ${xmlfile} 2>/dev/null | grep -q '^/tmp/' >/dev/null 2>&1; then
  vmpath=$imgname
  imgname=$(basename ${imgname})
# Else use same path as xml
else
  imgpath=${xmlpath}
  vmpath=${imgpath}/${imgname}
fi

# Check if virtual machine container file exists
if ! [ -e "${vmpath}" ]; then
  writelog "Virtual machine image ${vmpath} not found!"
  exit 1
fi

# Name of the virt machine, sed because of Windows formatting
vm_name=$(grep -o 'short_description param=.*"' ${xmlfile} \
          | sed -e "s/&.*;/; /g" | awk -F '"' '{print $2}')
# If ${vm_name} not defined use ${xmlfile}
vm_name=${vm_name:-${xmlfile%.xml}}

# Define vm_shortname since vm_name can be very long
vm_shortname=$(basename ${xmlfile%.xml} | sed -e "s, ,-,g")

# vm_name = displayname, define for old scripts
displayname=${vm_name}

# image is for the following virtual machine 
xmlvirt=$(grep -o 'virtualmachine param=.*"' ${xmlfile} \
          | sed -e "s/&.*;/; /g" | awk -F '"' '{print $2}')

# choose the proper virtualization/emulator plugin
[ "x${xmlvirt}" != "x" -a "x${xmlvirt}" != "xqemukvm" -a \
  "x${xmlvirt}" != "xvirtualbox" -a "x${xmlvirt}" != "xvmware" ] && \
  xmlvirt="emufe"

# make a guess from the filename extension if ${xmlvirt} is empty
# (not set within the XML file)
# TODO: implement possibility to submit own configuration files
if [ -z "${xmlvirt}" ] && [ -n "${additional_config}" ]; then
  writelog "No virtual machine parameter defined in ${xmlfile}"
  writelog "Trying to guess VM...\c"
  case "$(cat ${additional_config} | tr \"[A-Z]\" \"[a-z]\")" in
    *config.version*|*virtualhw.version*|*independent-nonpersistent*|*vmdk*)
      xmlvirt="vmware"
    ;;
    *innotek*|*virtualbox*)
      xmlvirt="virtualbox"
    ;;
    *qemu*|*kvm*)
      xmlvirt="qemukvm"
    ;;
    *)
      xmlvirt="none"
    ;;
  esac
elif [ -z "${xmlvirt}" ]; then
  case "$(echo ${imgname##*.} | tr \"[A-Z]\" \"[a-z]\")" in
    vmdk)
      xmlvirt="vmware"
    ;;
    vbox|vdi)
      xmlvirt="virtualbox"
    ;;
    qcow*)
      xmlvirt="qemukvm"
    ;;
    *)
      xmlvirt="emufe"
    ;;
  esac
  writelog "result:\t${xmlvirt}"
fi

# Definition of the client system
vmostype=$(grep -io '<os param=.*"' ${xmlfile} | awk -F '"' '{ print $2 }' |\
  tr "[A-Z]" "[a-z]")

# Definition of the networking the client system is connected to
network_kind=$(grep -io '<network param=.*"' ${xmlfile} \
               | awk -F '"' '{ print $2 }' | tr "[A-Z]" "[a-z]")
network_card=$(grep -io '<netcard param=.*"' ${xmlfile} \
               | awk -F '"' '{ print $2 }'| tr "[A-Z]" "[a-z]")

# Set redirects to 0, see vmgrid if you want to define some
redirects=0

# Serial/parallel ports defined (e.g. "ttyS0" or "autodetect")
serial=$(grep -io '<serialport param=.*"' ${xmlfile} \
         | awk -F '"' '{ print $2 }')
parallel=$(grep -io '<parport param=.*"' ${xmlfile} \
         | awk -F '"' '{ print $2 }')

writelog "\tVirtualization:\t\t$xmlvirt"
writelog "\tVM name:\t\t$vm_name"
writelog "\tVM short name:\t\t$vm_shortname"

###############################################################################
### Declaration of default variables
###############################################################################

# VM-ID static (00)
VM_ID="00"
# take last two digits of current pid...
VM_ID=$(expr substr $$ $(expr ${#$} - 1) 2)

# Make sure cpu_cores is not empty
cpu_cores=${cpu_cores:-"1"}

# Total amount of memory defined in stage 3
# TODO: Should be dependent on the setup (if diff is written to RAM ...)
permem=60
if [ "x${VMCHOOSER_FORCE_HALF_MEM}" == "x1" ]; then
    permem=30
fi
# Get a result which can be divided through 4
mem=$(expr ${totalmem} / 100 \* ${permem} / 4 \* 4)
if [ -n "${mainvirtmem}" ]; then
  forcemem=$(expr ${mainvirtmem} / 4 \* 4)
  mem=${forcemem}
fi
hostmem=$(expr ${totalmem} - ${mem})

# Configuring ethernet mac address: first 3 bytes are fixed (00:50:56) 
# 4th byte is the VM-ID (0D)
# last two bytes are taken from the bridge of the host
# define one MAC per guest
macguestpart="00:50:56:${VM_ID}"
machostpart=$(echo ${hostmacaddr} | awk -F ":" '{print $(NF-1)":"$NF}')
macaddr=$(echo "${macguestpart}:${machostpart}" | tr "[a-z]" "[A-Z]")

# Virtual fd/cd/dvd and drive devices, floppy b: for configuration
# if $floppy_0 from run-virt.include set then fdtest="TRUE"
fdtest=
fdtest=${floppy_0:+"TRUE"}
# if $fdtest not set floppy0="FALSE", else "TRUE"
floppy0=${fdtest:-"FALSE"}
floppy1="TRUE"
floppy1name="${PLUGINCONFDIR}/loopimg/fd.img"
# if $cdrom_0 from run-virt.include set then cdtest="TRUE"
cdtest=
cdtest=${cdrom_0:+"TRUE"}
# if $cdtest not set cdrom0="FALSE", else "TRUE"
cdrom0=${cdtest:-"FALSE"}
# if $cdrom_1 from run-virt.include set then cdtest="TRUE"
cdtest=
cdtest=${cdrom_1:+"TRUE"}
# if $cdtest not set cdrom1="FALSE", else "TRUE"
cdrom1=${cdtest:-"FALSE"}
# IDE is expected default, test for the virtual disk image type should
# be done while creating the runscripts ...
ide="TRUE"
scsi="FALSE"
hddrv="ide"
audio="true"
remotedesktopport="590${VM_ID}"

# Display resolution within the host system
hostres=$(xvidtune -show 2>/dev/null| grep -ve "^$")
xres=$(echo "${hostres}" | awk '{print $3}')
yres=$(echo "${hostres}" | awk '{print $7}')

# Resolution defined via xml parameter: fullscreen, full/X*Y/depth; windowed, 
# win/X*Y/depth
userres=$(grep -io '<screen param=.*"' ${xmlfile} | awk -F '"' '{ print $2 }' | \
  tr "A-Z" "a-z")
case "${userres}" in
  full*)
    res=$(echo "${hostres}" | awk -F "/" '{print $2}')
    uxres=${res%\**}
    uyres=${#*\*}
    userres="full"
  ;;
  win*)
    res=$(echo "${hostres}" | awk -F "/" '{print $2}')
    uxres=${res%\**}
    uyres=${#*\*}
    userres="win"
  ;;
esac


# Enable 3D
enable3d=$(grep -i "<enable3d param=.*" ${xmlfile} 2>/dev/null | \
           awk -F '=' {'print $2'} | tr "[A-Z]" "[a-z]")

# Add rw share
sharepath="${HOME}"
sharename="home"

# Set hostname: using original hostname and adding string
hostname="virt-$(hostname)"

writelog "\tVM Hostname:\t\t$hostname"

################################################################################
### Setup the rest of the environment and run the configured vm
################################################################################

# Adjust sound volume
writelog "Unmuting sound...\c "
amixer -q sset Master 80% unmute 2>/dev/null
amixer -q sset PCM 80% unmute 2>/dev/null
amixer -q sset CD 80% unmute 2>/dev/null
amixer -q sset Headphone 80% unmute 2>/dev/null
amixer -q sset Front 80% unmute 2>/dev/null      # in SUSE 11.0 it's headphone
amixer -q sset Speaker 80% unmute 2>/dev/null       # annoying built-in speaker
writelog "finished\n"

# Copy guest configuration (with added information) config.xml to be accessed
# via virtual floppy
# fixme -> to be changed (vmchooser adapts the file content!?)
#TODO: wozu echo?
#echo "Please fix the config.xml generation"
cp ${xmlfile} ${PLUGINCONFDIR}/fd-loop/config.xml

# Get all virtual machine specific stuff from the respective include file
if [ -e ${PLUGINCONFROOT}/${xmlvirt}/run-virt.include ] ; then
  self=${xmlvirt}
  . ${PLUGINCONFROOT}/${xmlvirt}/run-virt.include
  # start a windowmanager for easier handling
  # (expect problems /w windows opening in background /w vmware without wm)
  for dm in xfwm4 metacity openbox blackbox kwin fvwm2 ; do
    if which $dm >/dev/null 2>&1 ; then
      if [ "$dm" = "fvwm2" ] ; then
        echo "EdgeScroll 0 0" > ${redodir}/fvwm
        fvwm2 -f ${redodir}/fvwm >/dev/null 2>&1 &
      else
        $dm >/dev/null 2>&1 &
      fi
      break
    fi
  done
  # Start poolvideoswitch if we find the autostarter file
  if [ -e /etc/xdg/autostart/pvsgui.desktop ]; then
    /usr/local/bin/pvsgui -p 2 -b >/dev/null 2>&1 &
  fi
  eval ${VIRTCMD} ${VIRTCMDOPTS}
  writelog "Bye."

  # Postrun for commands after virtualization finishes
  if [ -n "${POSTRUN}" ]; then
    eval ${POSTRUN}  >/dev/null 2>&1
  fi

  cleanexit 0
else
  writelog "Failed because of missing ${xmlvirt} plugin."
  cleanexit 1
fi

# Postrun for commands after virtualization finishes
if [ -n "${POSTRUN}" ]; then
  eval ${POSTRUN}  >/dev/null 2>&1
fi

cleanexit 0
exit 0