create-vm

#!/bin/bash -eu
#
# Create a base libvirt guest VM
#

function pr_error()
{
	echo -e "\033[31m${*}\033[0m" 1>&2
}

function pr_warn()
{
	echo -e "\033[96m${*}\033[0m"
}

function pr_info()
{
	echo -e "\033[33m${*}\033[0m"
}

function out()
{
	local rc=${?}

	trap - EXIT INT TERM HUP

	if [ -n "${IMG_MOUNTP}" ] ; then
		unmount_image "${IMG_MOUNTP}"
	fi
	rm -rf "${TMP_DIR}"

	if [ "${rc}" -ne 0 ] ; then
		pr_error "Script failed"
	fi

	exit "${rc}"
}

function print_var()
{
	local var val

	for var in "${@}" ; do
		val=${!var}
		if [ -n "${val}" ] ; then
			pr_info "$(printf "%-13s: %s\n" "${var}" "${val}")"
		fi
	done
}

function mount_image()
{
	local image=${1} mountp=${2}
	local kernel

	# HACK: guestmount needs to be able to read the latest kernel
	kernel=$(find /boot/ -maxdepth 1 -name 'vmlinuz-*' | sort -V | tail -1)
	test -r "${kernel}" || sudo chmod 644 "${kernel}"

	guestmount --pid-file "${mountp}.pid" -a "${image}" -m /dev/sda1 --ro \
			   -o dev -o allow_root "${mountp}"
	IMG_MOUNTP=${mountp}
}

function unmount_image()
{
	local mountp=${1}
	local pid count

	pid=$(cat "${mountp}.pid")
	guestunmount "${mountp}"

	count=10
	while kill -0 "${pid}" 2>/dev/null && [ ${count} -gt 0 ] ; do
		sleep 1
		((count--))
	done

	if [ ${count} -eq 0 ] ; then
		pr_error "Failed to unmount image (timeout)"
		exit 1
	fi

	rm -f "${mountp}.pid"
	IMG_MOUNTP=
}
function url_valid()
{
	local url=${1}

	curl --head --silent --fail "${url}" 2>/dev/null
}

function download_image()
{
	local url=${1}
	local suffix tmp_img

	pr_info "Download image ${url}"

	tmp_img=${TMP_DIR}/base-img

	# Is it a compressed image?
	case "${url}" in
		*.xz)
			suffix=.xz
			;;
		*)
			suffix=
			;;
	esac

	# Download the image, decompress it and copy it to the cache
	wget -O "${tmp_img}${suffix}" "${url}"

	# Decompress the image
	if [ -n "${suffix}" ] ; then
			unxz -f "${tmp_img}${suffix}"
	fi

	# Move the image to the cache
	sudo mv "${tmp_img}" "${BASE_IMAGE}"
	sudo chmod 644 "${BASE_IMAGE}"
}

function download_fedora_image()
{
	local url pattern name

	if [ "${RELEASE}" -gt 27 ] ; then
		url=https://download.fedoraproject.org/pub/fedora/linux/releases/${RELEASE}/Cloud/${ARCH}/images
	else
		url=https://download.fedoraproject.org/pub/fedora/linux/releases/${RELEASE}/CloudImages/${ARCH}/images
	fi

	pattern=">Fedora-Cloud-Base-${RELEASE}-.*\.${ARCH}\.qcow2<"
	name=$(wget -q -O - "${url}" | grep -oP "${pattern}" | tr -d '><')

	url=${url}/${name}

	download_image "${url}"
}

function download_debian_image()
{
	local url name

	url=https://cdimage.debian.org/cdimage/cloud/${RELEASE}/daily/latest

	name=$(wget -q -O - "${url}"/SHA512SUMS | grep -- "-generic-${ARCH}-.*\.qcow" | sed 's/.* //')
	url=${url}/${name}

	download_image "${url}"
}

function download_ubuntu_image()
{
	local suffix relnum name url

	suffix=
	if [ "${RELEASE}" = "precise" ] || [ "${RELEASE}" = "trusty" ] || \
		   [ "${RELEASE}" = "xenial" ] ; then
		if [ "${BOOT_MODE}" = "uefi" ] ; then
			suffix="-uefi1"
		else
			suffix="-disk1"
		fi
	fi

	relnum=$(ubuntu-distro-info --series "${RELEASE}" --release)
	relnum=${relnum%% *}

	# Release image
	name=ubuntu-${relnum}-server-cloudimg-${ARCH}${suffix}.img
	url=https://cloud-images.ubuntu.com/releases/${RELEASE}/release/${name}
	if url_valid "${url}" ; then
		download_image "${url}"
		return
	fi

	# Daily image
	name=${RELEASE}-server-cloudimg-${ARCH}${suffix}.img
	url=https://cloud-images.ubuntu.com/daily/server/${RELEASE}/current/${name}
	if url_valid "${url}" ; then
		download_image "${url}"
		return
	fi

	pr_error "Faild to download image"
	exit 1
}

function download_core_image()
{
	local channel num name build url

	if [ -n "${GRADE}" ] ; then
		channel="${GRADE#-}"
	else
		channel="stable"
	fi

	num=${RELEASE#core}
	name=ubuntu-core-${num}-${ARCH}.img.xz
	for build in current pending ; do
		url=http://cdimage.ubuntu.com/ubuntu-core/${num}/${channel}/${build}/${name}
		if url_valid "${url}" ; then
			download_image "${url}"
			return
		fi
	done

	pr_error "Faild to download image"
	exit 1
}

function download_opensuse_image()
{
	local release name url

	if [ "${RELEASE}" = "tumbleweed" ] ; then
		url=https://download.opensuse.org/tumbleweed/appliances/openSUSE-Tumbleweed-JeOS.x86_64-OpenStack-Cloud.qcow2
	else
		release=${RELEASE^}
		name=openSUSE-${release}-OpenStack.x86_64.qcow2
		url=https://download.opensuse.org/repositories/Cloud:/Images:/${release/-/_}/images/${name}
	fi

	download_image "${url}"
}

function download_base_image()
{
	# Check if the image is already cached
	if [ -e "${BASE_IMAGE}" ] && [ "${DOWNLOAD}" -eq 0 ] ; then
		pr_info "Use cached base image"
		return
	fi

	# Download the image
	case "${RELEASE}" in
		core*)
			download_core_image
			;;
		*)
			download_"${VENDOR}"_image
	esac
}

function create_os_image()
{
	local tmp_xml tmp_mnt

	if virsh vol-info --pool default "${OS_IMAGE}" >/dev/null 2>&1 ; then
		pr_info "OS image exists already"
		return
	fi

	tmp_xml=${TMP_DIR}/os-image-xml
	tmp_mnt=${TMP_DIR}/os-image-mnt

	# Extract the kernel and initrd from the image for direct boot
	if [ "${BOOT_MODE}" = "direct" ] ; then
		pr_info "Extract kernel and initrd from base image"

		mkdir -p "${tmp_mnt}"
		mount_image "${BASE_IMAGE}" "${tmp_mnt}"

		# Create the libvirt volume for the kernel
		cat <<EOF >"${tmp_xml}"
<volume type='file'>
  <name>${KERNEL}</name>
  <capacity unit='bytes'>0</capacity>
  <target>
    <format type='raw'/>
  </target>
</volume>
EOF
		virsh vol-create --pool default "${tmp_xml}"
		virsh vol-upload --pool default "${KERNEL}" "${tmp_mnt}/boot/vmlinuz"

		# Create the libvirt volume for the initrd
		cat <<EOF >"${tmp_xml}"
<volume type='file'>
  <name>${INITRD}</name>
  <capacity unit='bytes'>0</capacity>
  <target>
    <format type='raw'/>
  </target>
</volume>
EOF
		virsh vol-create --pool default "${tmp_xml}"
		virsh vol-upload --pool default "${INITRD}" "${tmp_mnt}/boot/initrd.img"

		unmount_image "${tmp_mnt}"
	fi

	pr_info "Creating OS image"

	# Create the libvirt volume for the OS image
	cat <<EOF >"${tmp_xml}"
<volume type='file'>
  <name>${OS_IMAGE}</name>
  <capacity unit='bytes'>0</capacity>
  <target>
    <format type='qcow2'/>
  </target>
</volume>
EOF
	virsh vol-create --pool default "${tmp_xml}"
	virsh vol-upload --pool default "${OS_IMAGE}" "${BASE_IMAGE}"
	virsh vol-resize --pool default "${OS_IMAGE}" "${SIZE}"G
}

function create_config_drive()
{
	local public_key tmp_img tmp_xml tmp_dir

	if [ -z "${CONFIG_DRIVE}" ] ; then
		pr_info "No config drive required"
		return
	fi

	if virsh vol-info --pool default "${CONFIG_DRIVE}" >/dev/null 2>&1 ; then
		pr_info "Config drive exists already"
		return
	fi

	pr_info "Create config drive"

	public_key=$(cat ~/.ssh/id_rsa.pub)

	tmp_img=${TMP_DIR}/config-drive-img
	tmp_xml=${TMP_DIR}/config-drive-xml
	tmp_dir=${TMP_DIR}/config-drive-dir
	mkdir -p "${tmp_dir}"

	# meta data
	cat <<EOF >"${tmp_dir}/meta-data"
{ instance-id: $(uuidgen) }
EOF

	# user data
	cat <<EOF >"${tmp_dir}/user-data"
#cloud-config

hostname: ${NAME}.localdomain
manage_etc_hosts: localhost

chpasswd: { expire: false }
password: ${VENDOR}
ssh_authorized_keys: [ ${public_key} ]
ssh_pwauth: true

# Datasource timeout
max_wait: 2

# Copy the content of the config drive and run the setup-vm init script
runcmd:
  - |
    if ! [ -d /etc/cloud/cidata ] ; then
    test -d /mnt/cidata || mkdir /mnt/cidata
    dev=\$(findfs LABEL=cidata)
    mount \${dev} /mnt/cidata
    cp -aR /mnt/cidata/ /etc/cloud/
    umount /mnt/cidata
    /etc/cloud/cidata/setup-vm &
    fi
EOF

	# Copy the setup-vm init script and create its config file
	cp "${CONFIG_DIR}"/create-vm/setup-vm "${tmp_dir}"
	cat <<EOF >"${tmp_dir}"/setup-vm.config
REBOOT=${REBOOT}
SHUTDOWN=${SHUTDOWN}
TYPE=${TYPE}
EOF

	# Copy the APT ESM sources list
	if [ -e "${CONFIG_DIR}/${RELEASE}-esm-ppa.list" ] ; then
		cp "${CONFIG_DIR}/${RELEASE}-esm-ppa.list" "${tmp_dir}"/esm-ppa.list
	fi

	# Create the config drive ISO image
	genisoimage -ldots -allow-lowercase -allow-multidot -l -J -r \
				-o "${tmp_img}" -V cidata "${tmp_dir}"

	# Create the libvirt volume for the config drive
	cat <<EOF >"${tmp_xml}"
<volume type='file'>
  <name>${CONFIG_DRIVE}</name>
  <capacity unit='bytes'>0</capacity>
  <target>
    <format type='raw'/>
  </target>
</volume>
EOF
	virsh vol-create --pool default "${tmp_xml}"
	virsh vol-upload --pool default "${CONFIG_DRIVE}" "${tmp_img}"
}

function define_vm()
{
	local tmp_xml

	pr_info "Define VM"

	tmp_xml=${TMP_DIR}/vm-xml

	# Defaults
	XML_UEFI_BOOT_BEGIN="<!--"
	XML_UEFI_BOOT_END="-->"
	XML_DIRECT_BOOT_BEGIN="<!--"
	XML_DIRECT_BOOT_END="-->"
	XML_OS_IMAGE_DISK_SATA_BEGIN="<!--"
	XML_OS_IMAGE_DISK_SATA_END="-->"
	XML_OS_IMAGE_DISK_VIRTIO_BEGIN="<!--"
	XML_OS_IMAGE_DISK_VIRTIO_END="-->"
	XML_CONFIG_DRIVE_DISK_BEGIN="<!--"
	XML_CONFIG_DRIVE_DISK_END="-->"

	# Arch-specific XML settings
	case "${ARCH}" in
		i386|i686)
			XML_ARCH=i686
			;;
		amd64|x86_64)
			XML_ARCH=x86_64
			;;
		s390x)
			XML_ARCH=s390x
			;;
		arm64)
			XML_ARCH=aarch64
			;;
		armhf)
			XML_ARCH=armv7l
			;;
		ppc64el)
			XML_ARCH=ppc64le
			;;
		*)
			pr_error "Unsupported architecture: ${ARCH}"
			exit 1
			;;
	esac

	if [ "${BOOT_MODE}" = "uefi" ] ; then
		if [ -e /usr/share/OVMF/OVMF_CODE_4M.fd ] ; then
			XML_OVMF_CODE=/usr/share/OVMF/OVMF_CODE_4M.fd
		else
			XML_OVMF_CODE=/usr/share/OVMF/OVMF_CODE.fd
		fi
		XML_UEFI_BOOT_BEGIN=
		XML_UEFI_BOOT_END=
	elif [ "${BOOT_MODE}" = "direct" ] ; then
		XML_KERNEL_PATH=$(virsh vol-path --pool default "${KERNEL}")
		XML_INITRD_PATH=$(virsh vol-path --pool default "${INITRD}")
		XML_DIRECT_BOOT_BEGIN=
		XML_DIRECT_BOOT_END=
	fi

	XML_OS_IMAGE_PATH=$(virsh vol-path --pool default "${OS_IMAGE}")
	if [ "${RELEASE#core}" != "${RELEASE}" ] ; then
		# Ubuntu core is special :-(
		XML_OS_IMAGE_DISK_SATA_BEGIN=
		XML_OS_IMAGE_DISK_SATA_END=
	else
		XML_OS_IMAGE_DISK_VIRTIO_BEGIN=
		XML_OS_IMAGE_DISK_VIRTIO_END=
	fi

	if [ -n "${CONFIG_DRIVE}" ] ; then
		XML_CONFIG_DRIVE_PATH=$(virsh vol-path --pool default "${CONFIG_DRIVE}")
		XML_CONFIG_DRIVE_DISK_BEGIN=
		XML_CONFIG_DRIVE_DISK_END=
	fi

	XML_NAME=${NAME}
	XML_UUID=$(uuidgen)
	XML_MEMORY=${MEMORY}
	XML_VCPU=${VCPU}
	XML_VCPU_THREADS=${VCPU_THREADS}
	XML_MAC_ADDRESS="52:54:00:${XML_UUID:0:2}:${XML_UUID:2:2}:${XML_UUID:4:2}"

	# Export the variables for the domain XML
	# shellcheck disable=SC2090
	export XML_ARCH
	export XML_OVMF_CODE
	export XML_UEFI_BOOT_BEGIN XML_UEFI_BOOT_END
	export XML_KERNEL_PATH XML_INITRD_PATH \
		   XML_DIRECT_BOOT_BEGIN XML_DIRECT_BOOT_END
	export XML_OS_IMAGE_PATH \
		   XML_OS_IMAGE_DISK_SATA_BEGIN XML_OS_IMAGE_DISK_SATA_END \
		   XML_OS_IMAGE_DISK_VIRTIO_BEGIN XML_OS_IMAGE_DISK_VIRTIO_END
	export XML_CONFIG_DRIVE_PATH \
		   XML_CONFIG_DRIVE_DISK_BEGIN XML_CONFIG_DRIVE_DISK_END
	export XML_NAME XML_UUID XML_MEMORY XML_VCPU XML_VCPU_THREADS \
		   XML_MAC_ADDRESS

	# Create the domain XML and define the VM
	envsubst < "${CONFIG_DIR}/create-vm/domain-${XML_ARCH}.xml" > \
			 "${tmp_xml}"
	virsh define "${tmp_xml}"
}

function usage()
{
	cat <<EOF
Usage: create-vm [-a ARCH] [-b MODE] [-d] [-f] [-g GRADE] [-h] [-m SIZE] [-o]
                 [-s SIZE] [-t TYPE] [-y] DIST [NAME]

Create a libvirt guest VM.

Positional arguments:
  DIST                  A recognized distribution, like bionic, stretch,
                        fedora-26, ...
  NAME                  The libvirt domain name. If not specified, defaults to
                        <DIST>[-<ARCH>][-uefi].

Optional arguments:
  -a, --arch ARCH       Architecture of the VM. If not specified, defaults to
                        the host architecture.
  -b, --boot-mode MODE  Set the boot mode (bios, uefi, direct). If not
                        provided, defaults to 'bios'.
  -d, --debug           Enable debugging (set -x).
  -f, --force           Force the recreation of an existing VM.
  -g, --grade GRADE     Image grade (edge, beta, candidate, stable, dangerous-edge, ...).
  -h, --help            Show this help text and exit.
  -i, --image IMAGE     Use the image IMAGE as the base image.
  -m, --memory SIZE     Memory size in KB. If not provided, defaults to
                        1024(KB).
  -o, --download        Download and use a new cloud image rather than using an
                        already cached image.
  -s, --size SIZE       Image size in GB. If not provided, defaults to 8(GB).
  -t, --type TYPE       Create a VM of type <TYPE>. Valid types are:
                          dep8:  For dep8 kernel testing.
                          adt:   For ADT testing.
  -y, --dry-run
EOF
}

# -----------------------------------------------------------------------------
# Main entry point

ARCH=
FORCE=0
GRADE=
DOWNLOAD=0
SIZE=8
TYPE=
BOOT_MODE="bios"
DIST=
NAME=
DRY_RUN=0
MEMORY=1024
BASE_IMAGE=
VCPU=1
VCPU_THREADS=1
IMG_MOUNTP=

START=0
SHUTDOWN=0
REBOOT=1

while [ ${#} -gt 0 ] ; do
	case ${1} in
		-a|--arch)
			shift
			ARCH=${1}
			;;
		-b|--boot-mode)
			shift
			BOOT_MODE=${1}
			;;
		-d|--debug)
			export LIBGUESTFS_DEBUG=1
			set -x
			;;
		-f|--force)
			FORCE=1
			;;
		-g|--grade)
			shift
			GRADE=-${1}
			;;
		-h|--help)
			usage
			exit
			;;
		-i|--image)
			shift
			BASE_IMAGE=${1}
			;;
		-m|--memory)
			shift
			MEMORY=${1}
			;;
		-o|--download)
			DOWNLOAD=1
			;;
		-s|--size)
			shift
			SIZE=${1}
			;;
		-t|--type)
			shift
			TYPE=${1}
			;;
		-y|--dry-run)
			DRY_RUN=1
			;;
		-*)
			pr_error "Unexpected option: ${1}"
			exit 2
			;;
		*)
			if [ -z "${DIST}" ] ; then
				DIST=${1}
			elif [ -z "${NAME}" ] ; then
				NAME=${1}
			else
				pr_error "Unexpected argument: ${1}"
				exit 2
			fi
			;;
	esac
	shift
done

if [ -z "${DIST}" ] ; then
	usage
	exit 2
fi

case "${BOOT_MODE}" in
	bios|uefi|direct) ;;
	*)
		pr_error "Invalid boot mode: ${BOOT_MODE}"
		exit 1
		;;
esac

case "${TYPE}" in
	""|dep8|adt) ;;
	*)
		pr_error "Invalid type: ${TYPE}"
		exit 1
		;;
esac

if [ -n "${BASE_IMAGE}" ] && ! [ -e "${BASE_IMAGE}" ] ; then
	pr_error "No such image file: ${BASE_IMAGE}"
	exit 1
fi

# -----------------------------------------------------------------------------
# Set global variables

# The image vendor and release
case "${DIST}" in
	leap-*|tumbleweed)
		VENDOR=opensuse
		RELEASE=${DIST}
		;;
	*-*)
		VENDOR=${DIST%-*}
		RELEASE=${DIST#*-}
		;;
	sid|trixie|bookworm|bullseye)
		VENDOR=debian
		RELEASE=${DIST}
		;;
	*)
		VENDOR=ubuntu
		RELEASE=${DIST}
		;;
esac

# The vendor specific host architecture name
case "${VENDOR}" in
	fedora|centos|opensuse)
		host_arch=$(dpkg-architecture -qDEB_HOST_GNU_CPU)
		;;
	*)
		host_arch=$(dpkg-architecture -qDEB_HOST_ARCH)
		;;
esac

# Set the image architecture if not specified
if [ -z "${ARCH}" ] ; then
	ARCH=${host_arch}
fi

# Check/force the boot mode for certain releases
case "${RELEASE}/${ARCH}/${BOOT_MODE}" in
	precise/*/uefi)
		pr_error "Unsupported boot mode for Precise: uefi"
		exit 1
		;;
	*/armhf/bios)
		pr_error "Unsupported boot mode for armhf: bios"
		exit 1
		;;
	*/arm64/*)
		if [ "${BOOT_MODE}" != "uefi" ] ; then
			pr_warn "Force boot mode to: uefi"
			BOOT_MODE="uefi"
		fi
		;;
	core*/*)
		if [ "${BOOT_MODE}" != "uefi" ] ; then
			pr_warn "Force boot mode to: uefi"
			BOOT_MODE="uefi"
		fi
		;;
esac

# The name of the VM
if [ -z "${NAME}" ] ; then
	NAME=${VENDOR}-${RELEASE}${GRADE}
	if [ "${ARCH}" != "${host_arch}" ] ; then
		NAME=${NAME}-${ARCH}
	fi
	if [ "${BOOT_MODE}" != "bios" ] ; then
		NAME=${NAME}-${BOOT_MODE}
	fi
	if [ -n "${TYPE}" ] ; then
		NAME=${NAME}-${TYPE}
	fi
fi

# Type-specific special handling
case "${TYPE}" in
	dep8)
		VCPU=2
		VCPU_THREADS=2
		MEMORY=2048
		;;
	adt)
		VCPU=2
		VCPU_THREADS=2
		MEMORY=2048
		NAME=adt-${RELEASE}-${ARCH}
		START=1
		SHUTDOWN=1
		;;
esac

# Ubuntu core special handling
config_drive=1
if [ "${RELEASE#core}" != "${RELEASE}" ] ; then
	# Ubuntu core doesn't need a config drive
	config_drive=0
	if [ "${SIZE}" -lt 12 ] ; then
		# Ubuntu core2* is big :-(
		SIZE=12
	fi
	if [ "${MEMORY}" -lt 2048 ] ; then
		# 1GB is not enough for grub to loopmount the kernel snap
		MEMORY=2048
	fi
fi

# OpenSUSE special handling
if [ "${VENDOR}" = "opensuse" ] ; then
	if [ "${SIZE}" -lt 12 ] ; then
		SIZE=12
	fi
fi

# Image and config directories
IMAGES_DIR=/data/images/cloud
if ! [ -d "${IMAGES_DIR}" ] ; then
	IMAGES_DIR=~/.cache/images/cloud
	if ! [ -d "${IMAGES_DIR}" ] ; then
		mkdir -p "${IMAGES_DIR}"
	fi
fi
CONFIG_DIR=$(dirname "$(readlink -e "${0}")")/config

# The full path of the (cached) base image
if [ -z "${BASE_IMAGE}" ] ; then
	BASE_IMAGE=${IMAGES_DIR}/${VENDOR}-${RELEASE}${GRADE}-${ARCH}.img
fi

# The OS and config drive image names
OS_IMAGE=${NAME}.img
if [ "${config_drive}" -eq 1 ] ; then
	CONFIG_DRIVE=${NAME}-config.iso
else
	CONFIG_DRIVE=
fi

# The kernel and initrd images for direct boot
if [ "${BOOT_MODE}" = "direct" ] ; then
	KERNEL=${NAME}-kernel
	INITRD=${NAME}-initrd
else
	KERNEL=
	INITRD=
fi

print_var NAME VCPU VCPU_THREADS MEMORY ARCH VENDOR DIST RELEASE BOOT_MODE \
		  GRADE OS_IMAGE CONFIG_DRIVE KERNEL INITRD BASE_IMAGE

echo

# Check if this is a dry run
if [ "${DRY_RUN}" -eq 1 ] ; then
	echo "(dry-run) Exiting..."
	exit
fi

# Purge existing VM
if virsh dumpxml "${NAME}" >/dev/null 2>&1 ; then
	if [ "${FORCE}" -eq 0 ] ; then
		pr_error "VM '${NAME}' exists already. Use -f, --force to recreate it."
		exit 1
	fi
	virsh destroy "${NAME}" || true
	for vol in "${OS_IMAGE}" "${CONFIG_DRIVE}" "${KERNEL}" "${INITRD}" ; do
		virsh vol-delete --pool default "${vol}" 2>/dev/null || true
	done
	virsh undefine --nvram "${NAME}" || true
fi

# Create a temporary working directory and install a cleanup handler
TMP_DIR=$(mktemp -d)
trap "out" EXIT INT TERM HUP

# Download the cloud image
download_base_image

# Create the OS image
create_os_image

# Create the config drive
create_config_drive

# Define the VM
define_vm

# Start the VM
if [ "${START}" -eq 1 ] ; then
	pr_info "Start VM"
	virsh start "${NAME}"
fi