1083 lines
36 KiB
Python
Executable File
1083 lines
36 KiB
Python
Executable File
#!/usr/bin/python -tt
|
|
#
|
|
# Script to set up a Xen guest and kick off an install
|
|
#
|
|
# Copyright 2005-2006 Red Hat, Inc.
|
|
# Jeremy Katz <katzj@redhat.com>
|
|
# Option handling added by Andrew Puch <apuch@redhat.com>
|
|
#
|
|
# This program is free software; you can redistribute it and/or modify
|
|
# it under the terms of the GNU General Public License as published by
|
|
# the Free Software Foundation; either version 2 of the License, or
|
|
# (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU General Public License
|
|
# along with this program; if not, write to the Free Software
|
|
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
|
|
# MA 02110-1301 USA.
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import re
|
|
import logging
|
|
import optparse
|
|
|
|
import libvirt
|
|
import urlgrabber.progress as progress
|
|
|
|
import virtinst
|
|
import virtinst.cli as cli
|
|
from virtinst.cli import fail, print_stdout, print_stderr
|
|
|
|
|
|
##############################
|
|
# Validation utility helpers #
|
|
##############################
|
|
|
|
install_methods = "--location URL, --cdrom CD/ISO, --pxe, --import, --boot hd|cdrom|..."
|
|
install_missing = (_("An install method must be specified\n(%(methods)s)") %
|
|
{"methods" : install_methods})
|
|
disk_missing = _("--disk storage must be specified (override with --nodisks)")
|
|
|
|
|
|
def install_specified(location, cdpath, pxe, import_install):
|
|
return bool(pxe or cdpath or location or import_install)
|
|
|
|
|
|
def cdrom_specified(guest, diskopts=None):
|
|
disks = guest.get_devices("disk")
|
|
|
|
for disk in disks:
|
|
if disk.device == virtinst.VirtualDisk.DEVICE_CDROM:
|
|
return True
|
|
|
|
# Probably haven't set up disks yet
|
|
if not disks and diskopts:
|
|
for opts in diskopts:
|
|
if opts.count("device=cdrom"):
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def storage_specified(disks, nodisks, filesystems):
|
|
return bool(disks or nodisks or filesystems)
|
|
|
|
|
|
def supports_pxe(guest):
|
|
"""
|
|
Return False if we are pretty sure the config doesn't support PXE
|
|
"""
|
|
for nic in guest.get_devices("interface"):
|
|
if nic.type == nic.TYPE_USER:
|
|
continue
|
|
if nic.type != nic.TYPE_VIRTUAL:
|
|
return True
|
|
|
|
try:
|
|
netobj = nic.conn.networkLookupByName(nic.source)
|
|
xmlobj = virtinst.Network(nic.conn, parsexml=netobj.XMLDesc(0))
|
|
if xmlobj.can_pxe():
|
|
return True
|
|
except:
|
|
logging.debug("Error checking if PXE supported", exc_info=True)
|
|
return True
|
|
|
|
return False
|
|
|
|
|
|
def check_cdrom_option_error(options):
|
|
if options.cdrom_short and options.cdrom:
|
|
fail("Cannot specify both -c and --cdrom")
|
|
|
|
if options.cdrom_short:
|
|
if "://" in options.cdrom_short:
|
|
fail("-c specified with what looks like a URI. Did you mean "
|
|
"to use --connect? If not, use --cdrom instead")
|
|
options.cdrom = options.cdrom_short
|
|
|
|
if not options.cdrom:
|
|
return
|
|
|
|
# Catch a strangely common error of users passing -vcpus=2 instead of
|
|
# --vcpus=2. The single dash happens to map to enough shortened options
|
|
# that things can fail weirdly if --paravirt is also specified.
|
|
for vcpu in [o for o in sys.argv if o.startswith("-vcpu")]:
|
|
if options.cdrom == vcpu[3:]:
|
|
fail("You specified -vcpus, you want --vcpus")
|
|
|
|
|
|
##############################
|
|
# Device validation wrappers #
|
|
##############################
|
|
|
|
def convert_old_sound(options):
|
|
if options.sound:
|
|
return
|
|
if not options.old_sound_bool:
|
|
return
|
|
options.sound = "default"
|
|
|
|
|
|
def get_disks(guest, disks, nodisks, need_storage):
|
|
if nodisks:
|
|
return
|
|
|
|
if not disks and need_storage and cli.is_prompt():
|
|
disks = [None]
|
|
|
|
for diskopts in disks:
|
|
try:
|
|
if diskopts is None:
|
|
dev = None
|
|
sparse = True
|
|
size = None
|
|
path = None
|
|
else:
|
|
# We skip validation here, since we may have converted
|
|
# --file-size to --disk size=8 which doesn't validate on
|
|
# its own.
|
|
dev, size = cli.parse_disk(guest, diskopts, validate=False)
|
|
path = dev.path
|
|
sparse = dev.get_sparse()
|
|
|
|
d = cli.disk_prompt(guest.conn, path, size, sparse, origdev=dev)
|
|
d.validate()
|
|
except ValueError, e:
|
|
fail(_("Error with storage parameters: %s" % str(e)))
|
|
|
|
guest.add_device(d)
|
|
|
|
|
|
def convert_old_disks(options):
|
|
if options.diskopts or options.nodisks:
|
|
return
|
|
|
|
paths = virtinst.util.listify(options.file_paths)
|
|
sizes = virtinst.util.listify(options.disksize)
|
|
|
|
def padlist(l, padsize):
|
|
l = virtinst.util.listify(l)
|
|
l.extend((padsize - len(l)) * [None])
|
|
return l
|
|
|
|
disklist = padlist(paths, max(0, len(sizes)))
|
|
sizelist = padlist(sizes, len(disklist))
|
|
|
|
opts = []
|
|
for idx in range(len(disklist)):
|
|
optstr = ""
|
|
if disklist[idx]:
|
|
optstr += "path=%s" % disklist[idx]
|
|
if sizelist[idx]:
|
|
if optstr:
|
|
optstr += ","
|
|
optstr += "size=%s" % sizelist[idx]
|
|
if options.sparse is False:
|
|
if optstr:
|
|
optstr += ","
|
|
optstr += "sparse=no"
|
|
logging.debug("Converted to new style: --disk %s", optstr)
|
|
opts.append(optstr)
|
|
|
|
options.diskopts = opts
|
|
options.file_paths = []
|
|
options.disksize = None
|
|
options.sparse = True
|
|
|
|
|
|
########################
|
|
# Virt type validation #
|
|
########################
|
|
|
|
def prompt_virt(caps, arch, req_virt_type, req_accel):
|
|
supports_hvm = False
|
|
supports_pv = False
|
|
supports_accel = False
|
|
for guest in caps.guests:
|
|
if guest.os_type == "hvm":
|
|
supports_hvm = True
|
|
|
|
elif guest.os_type == "xen":
|
|
if (len(guest.domains) and
|
|
guest.domains[0].hypervisor_type == "kvm"):
|
|
# Don't prompt user for PV w/ xenner
|
|
continue
|
|
supports_pv = True
|
|
|
|
if not arch:
|
|
arch = caps.host.arch
|
|
|
|
if not req_virt_type:
|
|
if supports_hvm and supports_pv:
|
|
prompt_txt = _("Would you like a fully virtualized guest "
|
|
"(yes or no)? This will allow you to run "
|
|
"unmodified operating systems.")
|
|
|
|
if cli.prompt_for_yes_no(prompt_txt, ""):
|
|
req_virt_type = "hvm"
|
|
else:
|
|
req_virt_type = "xen"
|
|
|
|
elif supports_hvm:
|
|
req_virt_type = "hvm"
|
|
|
|
elif supports_pv:
|
|
req_virt_type = "xen"
|
|
|
|
# See if that domain supports acceleration
|
|
accel_type = ""
|
|
for guest in caps.guests:
|
|
if guest.os_type == req_virt_type and guest.arch == arch:
|
|
for dom in guest.domains:
|
|
if dom.is_accelerated():
|
|
supports_accel = True
|
|
accel_type = dom.hypervisor_type.upper()
|
|
|
|
if supports_accel and not req_accel:
|
|
prompt_txt = (_("Would you like to use %s acceleration? "
|
|
"(yes or no)") % accel_type)
|
|
|
|
req_accel = cli.prompt_for_yes_no(prompt_txt, "")
|
|
|
|
return (req_virt_type, req_accel)
|
|
|
|
|
|
def get_guest(conn, options):
|
|
# Set up all virt/hypervisor parameters
|
|
if sum([bool(f) for f in [options.fullvirt,
|
|
options.paravirt,
|
|
options.container]]) > 1:
|
|
fail(_("Can't do more than one of --hvm, --paravirt, or --container"))
|
|
|
|
req_accel = True
|
|
req_hv_type = options.hv_type and options.hv_type.lower() or None
|
|
if options.fullvirt:
|
|
req_virt_type = "hvm"
|
|
elif options.paravirt:
|
|
req_virt_type = "xen"
|
|
elif options.container:
|
|
req_virt_type = "exe"
|
|
else:
|
|
# This should force capabilities to give us the most sensible default
|
|
req_virt_type = None
|
|
|
|
if cli.is_prompt():
|
|
# User requested prompting but passed no virt type flag, ask for
|
|
# needed info
|
|
req_virt_type, req_accel = prompt_virt(conn.caps, options.arch,
|
|
req_virt_type, req_accel)
|
|
|
|
logging.debug("Requesting virt method '%s', hv type '%s'.",
|
|
(req_virt_type and req_virt_type or _("default")),
|
|
(req_hv_type and req_hv_type or _("default")))
|
|
|
|
arch = options.arch
|
|
if re.match("i.86", arch or ""):
|
|
arch = "i686"
|
|
|
|
try:
|
|
(capsguest,
|
|
capsdomain) = conn.caps.guest_lookup(
|
|
os_type=req_virt_type,
|
|
arch=arch,
|
|
typ=req_hv_type,
|
|
accelerated=req_accel,
|
|
machine=options.machine)
|
|
guest = conn.caps.build_virtinst_guest(conn, capsguest, capsdomain)
|
|
guest.os.machine = options.machine
|
|
except Exception, e:
|
|
fail(e)
|
|
|
|
if (not req_virt_type and
|
|
not req_hv_type and
|
|
req_accel and
|
|
conn.is_qemu() and
|
|
capsguest.arch in ["i686", "x86_64"] and
|
|
not capsdomain.is_accelerated()):
|
|
logging.warn("KVM acceleration not available, using '%s'",
|
|
capsdomain.hypervisor_type)
|
|
|
|
return guest
|
|
|
|
|
|
##################################
|
|
# Install media setup/validation #
|
|
##################################
|
|
|
|
def get_install_media(guest, location, cdpath, need_install):
|
|
manual_cdrom = cdrom_specified(guest)
|
|
cdinstall = bool(not location and (cdpath or cdrom_specified(guest)))
|
|
|
|
if not (location or cdpath or manual_cdrom or need_install):
|
|
return
|
|
|
|
try:
|
|
if not location and not cdinstall and cli.is_prompt():
|
|
media_prompt(guest)
|
|
else:
|
|
validate_install_media(guest, location, cdpath, cdinstall)
|
|
except ValueError, e:
|
|
fail(_("Error validating install location: %s" % str(e)))
|
|
|
|
|
|
def media_prompt(guest):
|
|
if guest.os.is_hvm():
|
|
prompt_txt = _("What is the install CD-ROM/ISO or URL?")
|
|
else:
|
|
prompt_txt = _("What is the install URL?")
|
|
|
|
while 1:
|
|
location = None
|
|
cdpath = None
|
|
media = cli.prompt_for_input("", prompt_txt, None)
|
|
|
|
if not len(media):
|
|
continue
|
|
|
|
if not guest.os.is_hvm() or media.count(":/"):
|
|
location = media
|
|
else:
|
|
cdpath = media
|
|
|
|
try:
|
|
validate_install_media(guest, location, cdpath)
|
|
except Exception, e:
|
|
logging.error(str(e))
|
|
continue
|
|
break
|
|
|
|
|
|
def validate_install_media(guest, location, cdpath, cdinstall=False):
|
|
if cdinstall or cdpath:
|
|
guest.installer.cdrom = True
|
|
if location or cdpath:
|
|
guest.installer.location = (location or cdpath)
|
|
guest.installer.check_location(guest)
|
|
|
|
|
|
#############################
|
|
# General option validation #
|
|
#############################
|
|
|
|
def validate_required_options(options, guest):
|
|
# Required config. Don't error right away if nothing is specified,
|
|
# aggregate the errors to help first time users get it right
|
|
msg = ""
|
|
need_storage = False
|
|
need_install = False
|
|
|
|
if not options.name:
|
|
msg += "\n" + cli.name_missing
|
|
|
|
if not options.memory:
|
|
msg += "\n" + cli.ram_missing
|
|
|
|
if (not guest.os.is_container() and
|
|
not storage_specified(options.diskopts,
|
|
options.nodisks,
|
|
options.filesystems)):
|
|
msg += "\n" + disk_missing
|
|
need_storage = True
|
|
|
|
if (not guest.os.is_container() and
|
|
(not install_specified(options.location, options.cdrom,
|
|
options.pxe, options.import_install)) and
|
|
(not cdrom_specified(guest, options.diskopts))):
|
|
msg += "\n" + install_missing
|
|
need_install = True
|
|
|
|
if msg and not cli.is_prompt():
|
|
fail(msg)
|
|
|
|
return need_storage, need_install
|
|
|
|
|
|
def check_option_collisions(options, guest):
|
|
# Disk collisions
|
|
if options.nodisks and (options.file_paths or
|
|
options.diskopts or
|
|
options.disksize):
|
|
fail(_("Cannot specify storage and use --nodisks"))
|
|
|
|
if ((options.file_paths or options.disksize or not options.sparse) and
|
|
options.diskopts):
|
|
fail(_("Cannot mix --file, --nonsparse, or --file-size with --disk "
|
|
"options. Use --disk PATH[,size=SIZE][,sparse=yes|no]"))
|
|
|
|
# Network collisions
|
|
if options.nonetworks:
|
|
if options.mac:
|
|
fail(_("Cannot use --mac with --nonetworks"))
|
|
if options.bridge:
|
|
fail(_("Cannot use --bridge with --nonetworks"))
|
|
if options.network:
|
|
fail(_("Cannot use --network with --nonetworks"))
|
|
return
|
|
|
|
# Install collisions
|
|
if sum([bool(l) for l in [options.pxe, options.location,
|
|
options.cdrom, options.import_install]]) > 1:
|
|
fail(_("Only one install method can be used (%(methods)s)") %
|
|
{"methods" : install_methods})
|
|
|
|
if (guest.os.is_container() and
|
|
install_specified(options.location, options.cdrom,
|
|
options.pxe, options.import_install)):
|
|
fail(_("Install methods (%s) cannot be specified for "
|
|
"container guests") % install_methods)
|
|
|
|
if guest.os.is_xenpv():
|
|
if options.pxe:
|
|
fail(_("Network PXE boot is not supported for paravirtualized "
|
|
"guests"))
|
|
if options.cdrom or options.livecd:
|
|
fail(_("Paravirtualized guests cannot install off cdrom media."))
|
|
|
|
if (options.location and
|
|
guest.conn.is_remote() and not
|
|
virtinst.support.support_remote_url_install(guest.conn)):
|
|
fail(_("Libvirt version does not support remote --location installs"))
|
|
|
|
if not options.location and options.extra:
|
|
fail(_("--extra-args only work if specified with --location."))
|
|
if not options.location and options.initrd_injections:
|
|
fail(_("--initrd-inject only works if specified with --location."))
|
|
|
|
|
|
##########################
|
|
# Guest building helpers #
|
|
##########################
|
|
|
|
def build_installer(options, conn, virt_type):
|
|
# Build the Installer instance
|
|
if options.livecd:
|
|
instclass = virtinst.LiveCDInstaller
|
|
elif options.pxe:
|
|
if options.nonetworks:
|
|
fail(_("Can't use --pxe with --nonetworks"))
|
|
|
|
instclass = virtinst.PXEInstaller
|
|
elif options.cdrom or options.location:
|
|
instclass = virtinst.DistroInstaller
|
|
elif options.import_install or options.bootopts:
|
|
if options.import_install and options.nodisks:
|
|
fail(_("A disk device must be specified with --import."))
|
|
options.import_install = True
|
|
instclass = virtinst.ImportInstaller
|
|
elif virt_type == "exe":
|
|
instclass = virtinst.ContainerInstaller
|
|
else:
|
|
instclass = virtinst.DistroInstaller
|
|
|
|
# Only set installer params here that impact the hw config, not
|
|
# anything to do with install media
|
|
installer = instclass(conn)
|
|
|
|
return installer
|
|
|
|
|
|
def build_guest_instance(conn, options):
|
|
guest = get_guest(conn, options)
|
|
|
|
logging.debug("Received virt method '%s'", guest.type)
|
|
logging.debug("Hypervisor name is '%s'", guest.os.os_type)
|
|
|
|
guest.installer = build_installer(options, conn, guest.os.os_type)
|
|
|
|
convert_old_sound(options)
|
|
cli.convert_old_networks(guest, options, not options.nonetworks and 1 or 0)
|
|
cli.convert_old_graphics(guest, options)
|
|
convert_old_disks(options)
|
|
cli.convert_old_features(options)
|
|
|
|
# Guest configuration
|
|
cli.get_uuid(guest, options.uuid)
|
|
cli.get_vcpus(guest, options.vcpus, options.check_cpu)
|
|
cli.parse_numatune(guest, options.numatune)
|
|
cli.parse_cpu(guest, options.cpu)
|
|
cli.parse_security(guest, options.security)
|
|
cli.parse_boot(guest, options.bootopts)
|
|
cli.parse_features(guest, options.features)
|
|
|
|
guest.autostart = options.autostart
|
|
guest.description = options.description
|
|
|
|
# Non-default devices
|
|
cli.get_controllers(guest, options.controller)
|
|
cli.get_redirdevs(guest, options.redirdev)
|
|
cli.get_memballoons(guest, options.memballoon)
|
|
cli.get_networks(guest, options.network)
|
|
cli.get_graphics(guest, options.graphics)
|
|
cli.get_videos(guest, options.video)
|
|
cli.get_watchdogs(guest, options.watchdog)
|
|
cli.get_filesystems(guest, options.filesystems)
|
|
cli.get_sounds(guest, options.sound)
|
|
cli.get_serials(guest, options.serials)
|
|
cli.get_parallels(guest, options.parallels)
|
|
cli.get_channels(guest, options.channels)
|
|
cli.get_consoles(guest, options.consoles)
|
|
cli.get_hostdevs(guest, options.hostdevs)
|
|
cli.get_smartcards(guest, options.smartcard)
|
|
cli.get_tpms(guest, options.tpm)
|
|
cli.get_rngs(guest, options.rng)
|
|
|
|
if not guest.get_devices("input"):
|
|
guest.add_default_input_device()
|
|
if not guest.get_devices("console") and not guest.get_devices("serial"):
|
|
guest.add_default_console_device()
|
|
if not guest.get_devices("video") and guest.get_devices("graphics"):
|
|
guest.add_default_video_device()
|
|
|
|
do_default_usb = all([d.type != "usb" for d in
|
|
guest.get_devices("controller")])
|
|
if do_default_usb:
|
|
guest.add_default_usb_controller()
|
|
|
|
# Install options
|
|
cli.set_os_variant(guest, options.distro_type, options.distro_variant)
|
|
guest.installer.extraargs = options.extra
|
|
guest.installer.initrd_injections = options.initrd_injections
|
|
guest.os.init = options.init
|
|
|
|
# Do this after setting up all optional parameters, so we report error
|
|
# about those first.
|
|
need_storage, need_install = validate_required_options(options, guest)
|
|
|
|
# Actually set required options
|
|
cli.get_name(guest, options.name)
|
|
cli.get_memory(guest, options.memory)
|
|
# Needs to come after setting memory
|
|
cli.get_cpuset(guest, options.cpuset)
|
|
|
|
get_disks(guest, options.diskopts, options.nodisks, need_storage)
|
|
get_install_media(guest, options.location, options.cdrom, need_install)
|
|
|
|
# Various little validations about option collisions. Need to do
|
|
# this after setting guest.installer at least
|
|
check_option_collisions(options, guest)
|
|
|
|
# Warnings
|
|
if options.pxe and not supports_pxe(guest):
|
|
logging.warn(_("The guest's network configuration does not support "
|
|
"PXE"))
|
|
|
|
return guest
|
|
|
|
|
|
###########################
|
|
# Install process helpers #
|
|
###########################
|
|
|
|
def _run_console(args):
|
|
logging.debug("Running: %s", " ".join(args))
|
|
child = os.fork()
|
|
if child:
|
|
return child
|
|
|
|
os.execvp(args[0], args)
|
|
os._exit(1) # pylint: disable=W0212
|
|
|
|
|
|
def vnc_console(dom, uri):
|
|
args = ["/usr/bin/virt-viewer",
|
|
"--connect", uri,
|
|
"--wait", str(dom.ID())]
|
|
|
|
if not os.path.exists(args[0]):
|
|
logging.warn(_("Unable to connect to graphical console: "
|
|
"virt-viewer not installed. Please install "
|
|
"the 'virt-viewer' package."))
|
|
return None
|
|
|
|
return _run_console(args)
|
|
|
|
|
|
def txt_console(dom, uri):
|
|
args = ["/usr/bin/virsh",
|
|
"--connect", uri,
|
|
"console", str(dom.ID())]
|
|
|
|
return _run_console(args)
|
|
|
|
|
|
def domain_is_crashed(domain):
|
|
"""
|
|
Return True if the created domain object is in a crashed state
|
|
"""
|
|
if not domain:
|
|
return False
|
|
|
|
dominfo = domain.info()
|
|
state = dominfo[0]
|
|
|
|
return state == libvirt.VIR_DOMAIN_CRASHED
|
|
|
|
|
|
def domain_is_shutdown(domain):
|
|
"""
|
|
Return True if the created domain object is shutdown
|
|
"""
|
|
if not domain:
|
|
return False
|
|
|
|
dominfo = domain.info()
|
|
|
|
state = dominfo[0]
|
|
cpu_time = dominfo[4]
|
|
|
|
if state == libvirt.VIR_DOMAIN_SHUTOFF:
|
|
return True
|
|
|
|
# If 'wait' was specified, the dom object we have was looked up
|
|
# before initially shutting down, which seems to bogus up the
|
|
# info data (all 0's). So, if it is bogus, assume the domain is
|
|
# shutdown. We will catch the error later.
|
|
return state == libvirt.VIR_DOMAIN_NOSTATE and cpu_time == 0
|
|
|
|
|
|
def connect_console(domain, consolecb, wait):
|
|
"""
|
|
Launched the passed console callback for the already defined
|
|
domain. If domain isn't running, return an error.
|
|
"""
|
|
child = None
|
|
if consolecb:
|
|
child = consolecb(domain)
|
|
|
|
if not child or not wait:
|
|
return
|
|
|
|
# If we connected the console, wait for it to finish
|
|
try:
|
|
os.waitpid(child, 0)
|
|
except OSError, e:
|
|
logging.debug("waitpid: %s: %s", e.errno, e.message)
|
|
|
|
|
|
def start_install(guest, continue_inst, options):
|
|
def show_console(dom):
|
|
xmlobj = virtinst.Guest(guest.conn, parsexml=dom.XMLDesc(0))
|
|
gdev = xmlobj.get_devices("graphics")
|
|
if not gdev:
|
|
logging.debug("Connecting to text console")
|
|
return txt_console(dom, guest.conn.getURI())
|
|
|
|
gtype = gdev[0].type
|
|
if gtype in [virtinst.VirtualGraphics.TYPE_VNC,
|
|
virtinst.VirtualGraphics.TYPE_SPICE]:
|
|
logging.debug("Launching virt-viewer for graphics type '%s'",
|
|
gtype)
|
|
return vnc_console(dom, guest.conn.getURI())
|
|
else:
|
|
logging.debug("No viewer to launch for graphics type '%s'",
|
|
gtype)
|
|
return None
|
|
|
|
# There are two main cases we care about:
|
|
#
|
|
# Scripts: these should specify --wait always, maintaining the
|
|
# semantics of virt-install exit implying the domain has finished
|
|
# installing.
|
|
#
|
|
# Interactive: If this is a continue_inst domain, we default to
|
|
# waiting. Otherwise, we can exit before the domain has finished
|
|
# installing. Passing --wait will give the above semantics.
|
|
#
|
|
wait_on_install = continue_inst
|
|
wait_time = -1
|
|
if options.wait is not None:
|
|
wait_on_install = True
|
|
wait_time = options.wait * 60
|
|
|
|
# If --wait specified, we don't want the default behavior of waiting
|
|
# for virt-viewer to exit, since then we can't exit the app when time
|
|
# expires
|
|
wait_on_console = not wait_on_install
|
|
|
|
# --wait 0 implies --noautoconsole
|
|
options.autoconsole = (wait_time != 0) and options.autoconsole or False
|
|
|
|
conscb = options.autoconsole and show_console or None
|
|
meter = (options.quiet and
|
|
progress.BaseMeter() or
|
|
progress.TextMeter(fo=sys.stdout))
|
|
logging.debug("Guest.has_install_phase: %s",
|
|
guest.installer.has_install_phase())
|
|
|
|
# we've got everything -- try to start the install
|
|
print_stdout(_("\nStarting install..."))
|
|
|
|
try:
|
|
start_time = time.time()
|
|
|
|
# Do first install phase
|
|
dom = guest.start_install(meter=meter, noboot=options.noreboot)
|
|
connect_console(dom, conscb, wait_on_console)
|
|
dom = check_domain(guest, dom, conscb,
|
|
wait_on_install, wait_time, start_time)
|
|
|
|
if continue_inst:
|
|
dom = guest.continue_install(meter=meter)
|
|
connect_console(dom, conscb, wait_on_console)
|
|
dom = check_domain(guest, dom, conscb,
|
|
wait_on_install, wait_time, start_time)
|
|
|
|
if options.noreboot or not guest.installer.has_install_phase():
|
|
print_stdout(
|
|
_("Domain creation completed. You can restart your domain by "
|
|
"running:\n %s") % cli.virsh_start_cmd(guest))
|
|
else:
|
|
print_stdout(
|
|
_("Guest installation complete... restarting guest."))
|
|
dom.create()
|
|
connect_console(dom, conscb, wait=True)
|
|
|
|
except KeyboardInterrupt:
|
|
logging.debug("", exc_info=True)
|
|
print_stderr(_("Domain install interrupted."))
|
|
raise
|
|
except RuntimeError, e:
|
|
fail(e)
|
|
except Exception, e:
|
|
fail(e, do_exit=False)
|
|
cli.install_fail(guest)
|
|
|
|
|
|
def check_domain(guest, dom, conscb, wait_for_install, wait_time, start_time):
|
|
"""
|
|
Make sure domain ends up in expected state, and wait if for install
|
|
to complete if requested
|
|
"""
|
|
wait_forever = (wait_time < 0)
|
|
|
|
# Wait a bit so info is accurate
|
|
def check_domain_state():
|
|
dominfo = dom.info()
|
|
state = dominfo[0]
|
|
|
|
if domain_is_crashed(guest.domain):
|
|
fail(_("Domain has crashed."))
|
|
|
|
if domain_is_shutdown(guest.domain):
|
|
return dom, state
|
|
|
|
return None, state
|
|
|
|
do_sleep = bool(conscb)
|
|
try:
|
|
ret, state = check_domain_state()
|
|
if ret:
|
|
return ret
|
|
except Exception, e:
|
|
# Sometimes we see errors from libvirt here due to races
|
|
logging.exception(e)
|
|
do_sleep = True
|
|
|
|
if do_sleep:
|
|
# Sleep a bit and try again to be sure the HV has caught up
|
|
time.sleep(2)
|
|
|
|
ret, state = check_domain_state()
|
|
if ret:
|
|
return ret
|
|
|
|
# Domain seems to be running
|
|
logging.debug("Domain state after install: %s", state)
|
|
|
|
if not wait_for_install or wait_time == 0:
|
|
# User either:
|
|
# used --noautoconsole
|
|
# used --wait 0
|
|
# killed console and guest is still running
|
|
if not guest.installer.has_install_phase():
|
|
return dom
|
|
|
|
print_stdout(
|
|
_("Domain installation still in progress. You can reconnect"
|
|
" to \nthe console to complete the installation process."))
|
|
sys.exit(0)
|
|
|
|
timestr = (not wait_forever and
|
|
_("%d minutes ") % (int(wait_time) / 60) or "")
|
|
print_stdout(
|
|
_("Domain installation still in progress. Waiting "
|
|
"%(time_string)s for installation to complete.") %
|
|
{"time_string": timestr})
|
|
|
|
# Wait loop
|
|
while True:
|
|
if domain_is_shutdown(guest.domain):
|
|
print_stdout(_("Domain has shutdown. Continuing."))
|
|
try:
|
|
# Lookup a new domain object incase current
|
|
# one returned bogus data (see comment in
|
|
# domain_is_shutdown)
|
|
dom = guest.conn.lookupByName(guest.name)
|
|
except Exception, e:
|
|
raise RuntimeError(_("Could not lookup domain after "
|
|
"install: %s" % str(e)))
|
|
break
|
|
|
|
time_elapsed = (time.time() - start_time)
|
|
if not wait_forever and time_elapsed >= wait_time:
|
|
print_stdout(
|
|
_("Installation has exceeded specified time limit. "
|
|
"Exiting application."))
|
|
sys.exit(1)
|
|
|
|
time.sleep(2)
|
|
|
|
return dom
|
|
|
|
|
|
########################
|
|
# XML printing helpers #
|
|
########################
|
|
|
|
def xml_to_print(guest, continue_inst, xmlonly, xmlstep, dry):
|
|
start_xml, final_xml = guest.start_install(dry=dry, return_xml=True)
|
|
second_xml = None
|
|
if not start_xml:
|
|
start_xml = final_xml
|
|
final_xml = None
|
|
|
|
if continue_inst:
|
|
second_xml, final_xml = guest.continue_install(dry=dry,
|
|
return_xml=True)
|
|
|
|
if dry and not (xmlonly or xmlstep):
|
|
print_stdout(_("Dry run completed successfully"))
|
|
return
|
|
|
|
# --print-xml
|
|
if xmlonly and not xmlstep:
|
|
if second_xml or final_xml:
|
|
fail(_("--print-xml can only be used with guests that do not have "
|
|
"an installation phase (--import, --boot, etc.). To see all"
|
|
" generated XML, please use --print-step all."))
|
|
return start_xml
|
|
|
|
# --print-step
|
|
if xmlstep == "1":
|
|
return start_xml
|
|
if xmlstep == "2":
|
|
if not (second_xml or final_xml):
|
|
fail(_("Requested installation does not have XML step 2"))
|
|
return second_xml or final_xml
|
|
if xmlstep == "3":
|
|
if not second_xml:
|
|
fail(_("Requested installation does not have XML step 3"))
|
|
return final_xml
|
|
|
|
# "all" case
|
|
xml = start_xml
|
|
if second_xml:
|
|
xml += second_xml
|
|
if final_xml:
|
|
xml += final_xml
|
|
return xml
|
|
|
|
|
|
#######################
|
|
# CLI option handling #
|
|
#######################
|
|
|
|
def parse_args():
|
|
parser = cli.setupParser(
|
|
"%prog --name NAME --ram RAM STORAGE INSTALL [options]",
|
|
_("Create a new virtual machine from specified install media."))
|
|
cli.add_connect_option(parser)
|
|
|
|
geng = optparse.OptionGroup(parser, _("General Options"))
|
|
geng.add_option("-n", "--name", dest="name",
|
|
help=_("Name of the guest instance"))
|
|
geng.add_option("-r", "--ram", type="int", dest="memory",
|
|
help=_("Memory to allocate for guest instance in "
|
|
"megabytes"))
|
|
cli.vcpu_cli_options(geng)
|
|
geng.add_option("--description", dest="description",
|
|
help=_("Human readable description of the VM to store in "
|
|
"the generated XML."))
|
|
geng.add_option("--security", dest="security",
|
|
help=_("Set domain security driver configuration."))
|
|
geng.add_option("--numatune", dest="numatune",
|
|
help=_("Tune NUMA policy for the domain process."))
|
|
geng.add_option("--features", dest="features",
|
|
help=_("Set domain <features> XML. Ex:\n"
|
|
"--features acpi=off\n"
|
|
"--features apic=on,eoi=on"))
|
|
parser.add_option_group(geng)
|
|
|
|
insg = optparse.OptionGroup(parser, _("Installation Method Options"))
|
|
insg.add_option("-c", dest="cdrom_short", help=optparse.SUPPRESS_HELP)
|
|
insg.add_option("--cdrom", dest="cdrom",
|
|
help=_("CD-ROM installation media"))
|
|
insg.add_option("-l", "--location", dest="location",
|
|
help=_("Installation source (eg, nfs:host:/path, "
|
|
"http://host/path, ftp://host/path)"))
|
|
insg.add_option("--pxe", action="store_true", dest="pxe",
|
|
help=_("Boot from the network using the PXE protocol"))
|
|
insg.add_option("--import", action="store_true", dest="import_install",
|
|
help=_("Build guest around an existing disk image"))
|
|
insg.add_option("--init", dest="init",
|
|
help=_("Path to init binary for container guest. Ex:\n"
|
|
"--init /path/to/app (to contain an application)\n"
|
|
"--init /sbin/init (for a full OS container)"))
|
|
insg.add_option("--livecd", action="store_true", dest="livecd",
|
|
help=_("Treat the CD-ROM media as a Live CD"))
|
|
insg.add_option("-x", "--extra-args", dest="extra",
|
|
default="",
|
|
help=_("Additional arguments to pass to the install kernel "
|
|
"booted from --location"))
|
|
insg.add_option("--initrd-inject", dest="initrd_injections",
|
|
action="append",
|
|
help=_("Add given file to root of initrd from --location"))
|
|
cli.add_distro_options(insg)
|
|
insg.add_option("--boot", dest="bootopts", default="",
|
|
help=_("Optionally configure post-install boot order, "
|
|
"menu, permanent kernel boot, etc."))
|
|
parser.add_option_group(insg)
|
|
|
|
stog = optparse.OptionGroup(parser, _("Storage Configuration"))
|
|
stog.add_option("--disk", dest="diskopts", action="append",
|
|
help=_("Specify storage with various options. Ex.\n"
|
|
"--disk path=/my/existing/disk\n"
|
|
"--disk path=/my/new/disk,size=5 (in gigabytes)\n"
|
|
"--disk vol=poolname/volname,device=cdrom,bus=scsi,..."))
|
|
stog.add_option("--nodisks", action="store_true",
|
|
help=_("Don't set up any disks for the guest."))
|
|
cli.add_fs_option(stog)
|
|
|
|
# Deprecated storage options
|
|
stog.add_option("-f", "--file", dest="file_paths", action="append",
|
|
help=optparse.SUPPRESS_HELP)
|
|
stog.add_option("-s", "--file-size", type="float",
|
|
action="append", dest="disksize",
|
|
help=optparse.SUPPRESS_HELP)
|
|
stog.add_option("--nonsparse", action="store_false",
|
|
default=True, dest="sparse",
|
|
help=optparse.SUPPRESS_HELP)
|
|
parser.add_option_group(stog)
|
|
|
|
netg = cli.network_option_group(parser)
|
|
|
|
netg.add_option("--nonetworks", action="store_true",
|
|
help=_("Don't create network interfaces for the guest."))
|
|
parser.add_option_group(netg)
|
|
|
|
vncg = cli.graphics_option_group(parser)
|
|
vncg.add_option("--noautoconsole", action="store_false",
|
|
dest="autoconsole", default=True,
|
|
help=_("Don't automatically try to connect to the guest "
|
|
"console"))
|
|
parser.add_option_group(vncg)
|
|
|
|
devg = optparse.OptionGroup(parser, _("Device Options"))
|
|
cli.add_device_options(devg)
|
|
|
|
# Deprecated
|
|
devg.add_option("--sound", action="store_true", dest="old_sound_bool",
|
|
default=False, help=optparse.SUPPRESS_HELP)
|
|
parser.add_option_group(devg)
|
|
|
|
virg = optparse.OptionGroup(parser, _("Virtualization Platform Options"))
|
|
virg.add_option("-v", "--hvm", action="store_true", dest="fullvirt",
|
|
help=_("This guest should be a fully virtualized guest"))
|
|
virg.add_option("-p", "--paravirt", action="store_true", dest="paravirt",
|
|
help=_("This guest should be a paravirtualized guest"))
|
|
virg.add_option("--container", action="store_true", default=False,
|
|
dest="container",
|
|
help=_("This guest should be a container guest"))
|
|
virg.add_option("--virt-type", dest="hv_type",
|
|
default="",
|
|
help=_("Hypervisor name to use (kvm, qemu, xen, ...)"))
|
|
virg.add_option("--accelerate", action="store_true", default=False,
|
|
dest="accelerate", help=optparse.SUPPRESS_HELP)
|
|
virg.add_option("--arch", dest="arch",
|
|
help=_("The CPU architecture to simulate"))
|
|
virg.add_option("--machine", dest="machine",
|
|
help=_("The machine type to emulate"))
|
|
virg.add_option("-u", "--uuid", dest="uuid",
|
|
help=_("UUID for the guest."))
|
|
cli.add_old_feature_options(virg)
|
|
parser.add_option_group(virg)
|
|
|
|
misc = optparse.OptionGroup(parser, _("Miscellaneous Options"))
|
|
misc.add_option("--autostart", action="store_true", dest="autostart",
|
|
default=False,
|
|
help=_("Have domain autostart on host boot up."))
|
|
misc.add_option("--wait", type="int", dest="wait",
|
|
help=_("Minutes to wait for install to complete."))
|
|
|
|
cli.add_misc_options(misc, prompt=True, printxml=True, printstep=True,
|
|
noreboot=True, dryrun=True)
|
|
parser.add_option_group(misc)
|
|
|
|
(options, cliargs) = parser.parse_args()
|
|
return options, cliargs
|
|
|
|
|
|
###################
|
|
# main() handling #
|
|
###################
|
|
|
|
def main(conn=None):
|
|
cli.earlyLogging()
|
|
options, cliargs = parse_args()
|
|
|
|
# Default setup options
|
|
options.quiet = options.xmlstep or options.xmlonly or options.quiet
|
|
|
|
cli.setupLogging("virt-install", options.debug, options.quiet)
|
|
|
|
if cliargs:
|
|
fail(_("Unknown argument '%s'") % cliargs[0])
|
|
check_cdrom_option_error(options)
|
|
|
|
if options.distro_variant == "list":
|
|
logging.debug("OS list requested")
|
|
for t in virtinst.osdict.list_os(list_types=True):
|
|
for v in virtinst.osdict.list_os(typename=t.name):
|
|
print "%-20s : %s" % (v.name, v.label)
|
|
return 0
|
|
|
|
cli.set_force(options.force)
|
|
cli.set_prompt(options.prompt)
|
|
|
|
if conn is None:
|
|
conn = cli.getConnection(options.connect)
|
|
|
|
if options.xmlstep not in [None, "1", "2", "3", "all"]:
|
|
fail(_("--print-step must be 1, 2, 3, or all"))
|
|
|
|
guest = build_guest_instance(conn, options)
|
|
continue_inst = guest.get_continue_inst()
|
|
|
|
if options.xmlstep or options.xmlonly or options.dry:
|
|
xml = xml_to_print(guest, continue_inst,
|
|
options.xmlonly, options.xmlstep, options.dry)
|
|
if xml:
|
|
print_stdout(xml, do_force=True)
|
|
else:
|
|
start_install(guest, continue_inst, options)
|
|
|
|
return 0
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
sys.exit(main())
|
|
except SystemExit, sys_e:
|
|
sys.exit(sys_e.code)
|
|
except KeyboardInterrupt:
|
|
logging.debug("", exc_info=True)
|
|
print_stderr(_("Installation aborted at user request"))
|
|
except Exception, main_e:
|
|
fail(main_e)
|