2018-01-27 23:46:39 +03:00
#!/usr/bin/env python3
2013-03-18 01:06:52 +04:00
#
2014-02-12 13:21:38 +04:00
# Copyright 2005-2014 Red Hat, Inc.
2013-03-18 01:06:52 +04:00
#
2018-04-04 16:35:41 +03:00
# This work is licensed under the GNU GPLv2 or later.
2018-03-20 22:00:02 +03:00
# See the COPYING file in the top-level directory.
2013-03-18 01:06:52 +04:00
2014-01-19 02:01:43 +04:00
import argparse
2018-10-11 21:11:37 +03:00
import atexit
2014-01-19 02:01:43 +04:00
import logging
2013-03-18 01:06:52 +04:00
import sys
import time
2013-08-09 23:00:16 +04:00
import libvirt
2013-03-18 01:06:52 +04:00
import virtinst
2014-09-20 04:31:22 +04:00
from virtinst import cli
2013-03-18 01:06:52 +04:00
from virtinst.cli import fail, print_stdout, print_stderr
##############################
# Validation utility helpers #
##############################
install_methods = "--location URL, --cdrom CD/ISO, --pxe, --import, --boot hd|cdrom|..."
2013-04-13 22:34:52 +04:00
2018-09-02 23:27:34 +03:00
def all_install_options(options):
return [options.pxe, options.cdrom, options.location,
options.import_install]
2018-06-12 17:50:24 +03:00
def install_specified(options):
2018-09-02 23:27:34 +03:00
return any([bool(o) for o in all_install_options(options)])
2013-03-18 01:06:52 +04:00
2013-04-13 22:34:52 +04:00
2013-03-18 01:06:52 +04:00
def supports_pxe(guest):
"""
Return False if we are pretty sure the config doesn't support PXE
"""
2018-03-21 00:23:34 +03:00
for nic in guest.devices.interface:
2013-03-18 01:06:52 +04:00
if nic.type == nic.TYPE_USER:
continue
if nic.type != nic.TYPE_VIRTUAL:
return True
try:
2013-09-24 18:00:01 +04:00
netobj = nic.conn.networkLookupByName(nic.source)
2013-09-23 01:04:22 +04:00
xmlobj = virtinst.Network(nic.conn, parsexml=netobj.XMLDesc(0))
if xmlobj.can_pxe():
2013-03-18 01:06:52 +04:00
return True
2017-07-24 11:26:48 +03:00
except Exception:
2013-03-18 01:06:52 +04:00
logging.debug("Error checking if PXE supported", exc_info=True)
return True
return False
2013-04-21 20:28:14 +04:00
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
2013-04-04 20:04:07 +04:00
if not options.cdrom:
return
2013-04-21 20:28:14 +04:00
# 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.
2013-04-04 20:04:07 +04:00
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")
2015-04-05 00:10:45 +03:00
#################################
# Back compat option conversion #
#################################
def convert_old_printxml(options):
if options.xmlstep:
options.xmlonly = options.xmlstep
del(options.xmlstep)
2013-03-18 01:06:52 +04:00
2013-09-28 04:16:35 +04:00
def convert_old_sound(options):
2014-02-05 21:32:53 +04:00
if not options.sound:
2013-09-28 04:16:35 +04:00
return
2014-02-05 21:32:53 +04:00
for idx in range(len(options.sound)):
if options.sound[idx] is None:
options.sound[idx] = "default"
2013-03-18 01:06:52 +04:00
2014-01-22 00:36:34 +04:00
def convert_old_init(options):
if not options.init:
return
if not options.boot:
2018-10-01 20:14:43 +03:00
options.boot = [""]
options.boot[-1] += ",init=%s" % options.init
logging.debug("Converted old --init to --boot %s", options.boot[-1])
2014-01-22 00:36:34 +04:00
2014-09-21 03:16:13 +04:00
def _do_convert_old_disks(options):
2019-06-08 01:21:24 +03:00
paths = virtinst.xmlutil.listify(options.file_paths)
sizes = virtinst.xmlutil.listify(options.disksize)
2013-03-18 01:06:52 +04:00
def padlist(l, padsize):
2019-06-08 01:21:24 +03:00
l = virtinst.xmlutil.listify(l)
2013-03-18 01:06:52 +04:00
l.extend((padsize - len(l)) * [None])
return l
2013-09-28 04:16:35 +04:00
disklist = padlist(paths, max(0, len(sizes)))
sizelist = padlist(sizes, len(disklist))
2013-03-18 01:06:52 +04:00
2013-09-28 04:16:35 +04:00
opts = []
2016-04-18 23:42:12 +03:00
for idx, path in enumerate(disklist):
2013-09-28 04:16:35 +04:00
optstr = ""
2016-04-18 23:42:12 +03:00
if path:
optstr += "path=%s" % path
2013-09-28 04:16:35 +04:00
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)
2014-01-21 03:04:23 +04:00
options.disk = opts
2014-09-21 03:16:13 +04:00
def convert_old_disks(options):
if options.nodisks and (options.file_paths or
options.disk or
options.disksize):
fail(_("Cannot specify storage and use --nodisks"))
if ((options.file_paths or options.disksize or not options.sparse) and
options.disk):
fail(_("Cannot mix --file, --nonsparse, or --file-size with --disk "
"options. Use --disk PATH[,size=SIZE][,sparse=yes|no]"))
if not options.disk:
if options.nodisks:
options.disk = ["none"]
else:
_do_convert_old_disks(options)
del(options.file_paths)
del(options.disksize)
del(options.sparse)
del(options.nodisks)
logging.debug("Distilled --disk options: %s", options.disk)
2013-03-18 01:06:52 +04:00
2013-04-13 22:34:52 +04:00
2014-09-07 19:57:04 +04:00
def convert_old_os_options(options):
2019-02-07 22:09:37 +03:00
# Default to distro autodetection
distkey = "auto"
2019-02-07 23:48:40 +03:00
if options.os_variant:
2019-02-08 00:05:12 +03:00
distkey = options.os_variant
2019-02-07 23:48:40 +03:00
elif options.old_os_type:
2019-02-08 00:05:12 +03:00
distkey = options.old_os_type
2019-02-07 22:09:37 +03:00
2019-02-08 00:26:04 +03:00
options.os_variant = cli.parse_os_variant(distkey)
2019-02-07 23:48:40 +03:00
del(options.old_os_type)
2014-09-07 19:57:04 +04:00
2014-09-20 04:31:22 +04:00
def convert_old_memory(options):
if options.memory:
return
if not options.oldmemory:
return
options.memory = str(options.oldmemory)
def convert_old_cpuset(options):
if not options.cpuset:
return
if not options.vcpus:
2018-10-01 20:14:43 +03:00
options.vcpus = [""]
options.vcpus[-1] += ",cpuset=%s" % options.cpuset
logging.debug("Generated compat cpuset: --vcpus %s", options.vcpus[-1])
2014-09-20 04:31:22 +04:00
2014-09-21 02:56:39 +04:00
def convert_old_networks(options):
if options.nonetworks:
options.network = ["none"]
2019-06-08 01:21:24 +03:00
macs = virtinst.xmlutil.listify(options.mac)
networks = virtinst.xmlutil.listify(options.network)
bridges = virtinst.xmlutil.listify(options.bridge)
2014-09-20 04:31:22 +04:00
if bridges and networks:
fail(_("Cannot mix both --bridge and --network arguments"))
if bridges:
# Convert old --bridges to --networks
networks = ["bridge:" + b for b in bridges]
def padlist(l, padsize):
2019-06-08 01:21:24 +03:00
l = virtinst.xmlutil.listify(l)
2014-09-20 04:31:22 +04:00
l.extend((padsize - len(l)) * [None])
return l
# If a plain mac is specified, have it imply a default network
2014-09-21 02:56:39 +04:00
networks = padlist(networks, max(len(macs), 1))
2014-09-20 04:31:22 +04:00
macs = padlist(macs, len(networks))
2016-04-18 23:42:12 +03:00
for idx, ignore in enumerate(networks):
2014-09-20 04:31:22 +04:00
if networks[idx] is None:
networks[idx] = "default"
if macs[idx]:
networks[idx] += ",mac=%s" % macs[idx]
# Handle old format of bridge:foo instead of bridge=foo
for prefix in ["network", "bridge"]:
if networks[idx].startswith(prefix + ":"):
networks[idx] = networks[idx].replace(prefix + ":",
prefix + "=")
2014-09-21 02:56:39 +04:00
del(options.mac)
del(options.bridge)
del(options.nonetworks)
2014-09-20 04:31:22 +04:00
options.network = networks
2014-09-21 02:56:39 +04:00
logging.debug("Distilled --network options: %s", options.network)
2014-09-20 04:31:22 +04:00
2018-06-05 21:43:19 +03:00
def convert_old_graphics(options):
2014-09-20 04:31:22 +04:00
vnc = options.vnc
vncport = options.vncport
vnclisten = options.vnclisten
nographics = options.nographics
sdl = options.sdl
keymap = options.keymap
graphics = options.graphics
if graphics and (vnc or sdl or keymap or vncport or vnclisten):
fail(_("Cannot mix --graphics and old style graphical options"))
optnum = sum([bool(g) for g in [vnc, nographics, sdl, graphics]])
if optnum > 1:
raise ValueError(_("Can't specify more than one of VNC, SDL, "
"--graphics or --nographics"))
if options.graphics:
return
if optnum == 0:
return
# Build a --graphics command line from old style opts
optstr = ((vnc and "vnc") or
(sdl and "sdl") or
(nographics and ("none")))
if vnclisten:
optstr += ",listen=%s" % vnclisten
if vncport:
optstr += ",port=%s" % vncport
if keymap:
optstr += ",keymap=%s" % keymap
logging.debug("--graphics compat generated: %s", optstr)
options.graphics = [optstr]
def convert_old_features(options):
2018-10-01 20:14:43 +03:00
if options.features:
2014-09-20 04:31:22 +04:00
return
opts = ""
if options.noacpi:
opts += "acpi=off"
if options.noapic:
if opts:
opts += ","
opts += "apic=off"
2018-10-01 20:14:43 +03:00
if opts:
options.features = [opts]
2014-09-20 04:31:22 +04:00
2013-03-18 01:06:52 +04:00
##################################
# Install media setup/validation #
##################################
2018-09-07 03:28:05 +03:00
def do_test_media_detection(conn, options):
url = options.test_media_detection
guest = virtinst.Guest(conn)
if options.arch:
guest.os.arch = options.arch
if options.os_type:
guest.os.os_type = options.os_type
guest.set_capabilities_defaults()
2018-10-13 01:35:09 +03:00
installer = virtinst.Installer(conn, location=url)
2018-09-03 22:21:11 +03:00
print_stdout(installer.detect_distro(guest), do_force=True)
2014-09-21 04:32:19 +04:00
2013-03-18 01:06:52 +04:00
#############################
# General option validation #
#############################
2019-06-11 02:50:14 +03:00
def storage_specified(options, guest):
if guest.os.is_container():
return True
return options.disk or options.filesystem
def memory_specified(guest):
return guest.memory or guest.currentMemory or guest.cpu.cells
2018-09-03 22:21:11 +03:00
def validate_required_options(options, guest, installer):
2013-03-18 01:06:52 +04:00
# Required config. Don't error right away if nothing is specified,
# aggregate the errors to help first time users get it right
msg = ""
2019-06-11 02:50:14 +03:00
if not memory_specified(guest):
2014-06-16 07:56:02 +04:00
msg += "\n" + _("--memory amount in MiB is required")
2013-03-18 01:06:52 +04:00
2019-06-11 02:50:14 +03:00
if not storage_specified(options, guest):
2014-05-12 02:58:17 +04:00
msg += "\n" + (
2014-09-21 03:16:13 +04:00
_("--disk storage must be specified (override with --disk none)"))
2013-03-18 01:06:52 +04:00
2018-09-03 22:21:11 +03:00
if not installer:
2014-05-12 02:58:17 +04:00
msg += "\n" + (
_("An install method must be specified\n(%(methods)s)") %
2017-08-17 14:01:28 +03:00
{"methods": install_methods})
2013-03-18 01:06:52 +04:00
2014-02-05 01:16:39 +04:00
if msg:
2013-03-18 01:06:52 +04:00
fail(msg)
2013-04-13 22:34:52 +04:00
2014-09-07 21:50:22 +04:00
_cdrom_location_man_page = _("See the man page for examples of "
"using --location with CDROM media")
2018-09-03 22:21:11 +03:00
def check_option_collisions(options, guest, installer):
2016-06-01 16:32:56 +03:00
if options.noreboot and options.transient:
fail(_("--noreboot and --transient can not be specified together"))
2013-03-18 01:06:52 +04:00
# Install collisions
2018-09-02 23:27:34 +03:00
if sum([bool(l) for l in all_install_options(options)]) > 1:
2013-03-18 01:06:52 +04:00
fail(_("Only one install method can be used (%(methods)s)") %
2017-08-05 09:39:32 +03:00
{"methods": install_methods})
2013-03-18 01:06:52 +04:00
2018-09-02 23:27:34 +03:00
if guest.os.is_container() and install_specified(options):
2013-03-18 01:06:52 +04:00
fail(_("Install methods (%s) cannot be specified for "
"container guests") % install_methods)
2014-02-03 00:17:44 +04:00
cdrom_err = ""
2018-09-03 22:21:11 +03:00
if installer.cdrom:
2014-11-21 00:36:23 +03:00
cdrom_err = " " + _cdrom_location_man_page
2014-01-21 03:04:23 +04:00
if not options.location and options.extra_args:
2014-02-03 00:17:44 +04:00
fail(_("--extra-args only work if specified with --location.") +
cdrom_err)
2014-01-21 03:04:23 +04:00
if not options.location and options.initrd_inject:
2014-02-03 00:17:44 +04:00
fail(_("--initrd-inject only works if specified with --location.") +
cdrom_err)
2019-02-22 11:40:20 +03:00
if options.unattended:
if options.initrd_inject or options.extra_args:
fail(_("--unattended does not support --initrd-inject nor --extra-args."))
2014-02-03 00:17:44 +04:00
2018-09-03 22:21:11 +03:00
def _show_nographics_warnings(options, guest, installer):
2018-03-21 00:23:34 +03:00
if guest.devices.graphics:
2014-02-03 00:17:44 +04:00
return
if not options.autoconsole:
return
2014-11-21 21:57:30 +03:00
2018-09-03 22:21:11 +03:00
if installer.cdrom:
2017-05-05 21:21:15 +03:00
logging.warning(_("CDROM media does not print to the text console "
2014-02-03 00:17:44 +04:00
"by default, so you likely will not see text install output. "
2014-11-21 00:36:23 +03:00
"You might want to use --location.") + " " +
_cdrom_location_man_page)
2014-02-03 00:17:44 +04:00
return
if not options.location:
return
# Trying --location --nographics with console connect. Warn if
# they likely won't see any output.
2018-03-21 00:23:34 +03:00
if not guest.devices.console:
2017-05-05 21:21:15 +03:00
logging.warning(_("No --console device added, you likely will not "
2014-02-03 00:17:44 +04:00
"see text install output from the guest."))
return
2018-09-03 22:21:11 +03:00
def show_warnings(options, guest, installer):
2014-02-03 00:17:44 +04:00
if options.pxe and not supports_pxe(guest):
2017-05-05 21:21:15 +03:00
logging.warning(_("The guest's network configuration does not support "
2014-02-03 00:17:44 +04:00
"PXE"))
2018-10-13 19:55:34 +03:00
# Limit it to hvm x86 guests which presently our defaults
# only really matter for
2018-09-13 00:23:01 +03:00
if (guest.osinfo.name == "generic" and
2019-02-08 00:26:04 +03:00
not options.os_variant.is_none and
not options.os_variant.name == "generic" and
2018-10-13 19:55:34 +03:00
guest.os.is_x86() and guest.os.is_hvm()):
2017-05-05 21:21:15 +03:00
logging.warning(_("No operating system detected, VM performance may "
2014-09-07 21:55:45 +04:00
"suffer. Specify an OS with --os-variant for optimal results."))
2018-09-03 22:21:11 +03:00
_show_nographics_warnings(options, guest, installer)
2013-03-18 01:06:52 +04:00
##########################
# Guest building helpers #
##########################
2018-09-03 17:07:47 +03:00
def build_installer(options, guest):
2018-10-13 01:35:09 +03:00
cdrom = None
2018-09-03 17:07:47 +03:00
location = None
2019-02-01 02:07:09 +03:00
location_kernel = None
location_initrd = None
2018-10-12 22:15:20 +03:00
install_bootdev = None
2018-09-03 17:07:47 +03:00
2018-10-13 01:35:09 +03:00
has_installer = True
2019-02-22 11:40:08 +03:00
if options.unattended:
2019-03-05 23:50:11 +03:00
if options.os_variant.is_none or options.os_variant.is_auto:
fail(_("--unattended requires an explicit --os-variant"))
2019-03-29 00:44:48 +03:00
if not guest.osinfo.is_windows():
if options.cdrom:
options.location = options.cdrom
options.cdrom = None
options.os_variant.install = "location"
2019-02-22 11:40:08 +03:00
2019-06-08 17:05:58 +03:00
INSTALL_VALUES = ["location"]
if options.os_variant.install not in INSTALL_VALUES + [None]:
fail(_("Unknown --os-variant install value '%s'. Must be one of: %s") %
(options.os_variant.install, ", ".join(INSTALL_VALUES)))
2019-02-08 18:23:58 +03:00
if options.os_variant.install == "location":
if not options.location:
location = guest.osinfo.get_location(guest.os.arch)
2019-02-18 18:56:38 +03:00
logging.debug(
"Generated default libosinfo '--location %s'", location)
2019-02-08 18:23:58 +03:00
options.location = location
2018-10-13 01:35:09 +03:00
if options.location:
2019-02-01 02:07:09 +03:00
(location,
location_kernel,
location_initrd) = cli.parse_location(options.location)
2018-10-13 01:35:09 +03:00
elif options.cdrom:
cdrom = options.cdrom
2018-09-03 17:07:47 +03:00
elif options.pxe:
2018-10-12 22:15:20 +03:00
install_bootdev = "network"
2018-09-03 17:58:25 +03:00
elif (guest.os.is_container() or
options.import_install or
2018-09-03 17:07:47 +03:00
options.xmlonly or
options.boot):
2018-10-13 01:35:09 +03:00
pass
else:
has_installer = False
2013-03-18 01:06:52 +04:00
2018-10-13 01:35:09 +03:00
if not has_installer:
2018-09-03 17:07:47 +03:00
# This triggers an error in validate_required_options
return None
2018-10-13 01:35:09 +03:00
installer = virtinst.Installer(guest.conn,
cdrom=cdrom,
location=location,
2019-02-01 02:07:09 +03:00
location_kernel=location_kernel,
location_initrd=location_initrd,
2018-10-13 01:35:09 +03:00
install_bootdev=install_bootdev)
if cdrom and options.livecd:
2014-09-07 21:42:56 +04:00
installer.livecd = True
2019-02-22 11:40:20 +03:00
if options.unattended:
2019-02-22 11:40:21 +03:00
unattended_data = cli.parse_unattended(options.unattended)
options.unattended = None
installer.set_unattended_data(unattended_data)
2019-02-22 11:40:20 +03:00
else:
if options.extra_args:
installer.extra_args = options.extra_args
if options.initrd_inject:
installer.set_initrd_injections(options.initrd_inject)
2018-10-13 16:42:15 +03:00
if options.autostart:
installer.autostart = True
2013-03-18 01:06:52 +04:00
2019-02-07 22:30:00 +03:00
distro = None
try:
# This also validates the install location
autodistro = installer.detect_distro(guest)
2019-02-08 00:26:04 +03:00
if options.os_variant.is_auto:
2019-02-07 22:30:00 +03:00
distro = autodistro
except ValueError as e:
fail(_("Error validating install location: %s") % str(e))
if distro:
guest.set_os_name(distro)
2013-03-18 01:06:52 +04:00
return installer
2013-04-13 22:34:52 +04:00
2019-06-11 18:54:02 +03:00
def set_cli_defaults(options, guest):
if not guest.name:
default_name = virtinst.Guest.generate_name(guest)
cli.print_stdout(_("Using default --name {vm_name}").format(
vm_name=default_name))
guest.name = default_name
2019-02-07 22:37:25 +03:00
if guest.os.is_container():
return
2019-06-11 02:31:37 +03:00
2019-05-12 01:05:59 +03:00
res = guest.osinfo.get_recommended_resources()
storage = res.get_recommended_storage(guest.os.arch)
2019-06-11 02:31:37 +03:00
ram = res.get_recommended_ram(guest.os.arch)
ncpus = res.get_recommended_ncpus(guest.os.arch)
2019-06-11 02:50:14 +03:00
if ram and not memory_specified(guest):
2019-06-11 19:15:35 +03:00
mbram = str(ram / (1024 * 1024)).rstrip("0").rstrip(".")
cli.print_stdout(
_("Using {os_name} default --memory {megabytes}").format(
os_name=guest.osinfo.name, megabytes=mbram))
2019-06-11 02:31:37 +03:00
guest.currentMemory = ram // 1024
2019-06-11 02:50:14 +03:00
if ncpus:
# We need to do this upfront, so we don't incorrectly set guest.vcpus
guest.sync_vcpus_topology()
if not guest.vcpus:
2019-06-11 19:15:35 +03:00
# I don't think we need to print anything here as this was never
# a required value.
2019-06-11 02:50:14 +03:00
guest.vcpus = ncpus
2019-05-12 01:05:59 +03:00
2019-06-11 02:50:14 +03:00
if storage and not storage_specified(options, guest):
2019-06-11 02:31:37 +03:00
diskstr = 'size=%d' % (storage // (1024 ** 3))
2019-06-11 19:15:35 +03:00
cli.print_stdout(
_("Using {os_name} default --disk {disk_options}".format(
os_name=guest.osinfo.name, disk_options=diskstr)))
2019-06-11 02:31:37 +03:00
options.disk = [diskstr]
cli.ParserDisk(diskstr, guest=guest).parse(None)
2019-02-07 22:37:25 +03:00
2016-06-14 14:37:21 +03:00
def build_guest_instance(conn, options):
2018-09-07 02:07:15 +03:00
guest = virtinst.Guest(conn)
2013-03-18 01:06:52 +04:00
2014-02-05 01:16:39 +04:00
if options.name:
guest.name = options.name
2014-01-21 03:15:08 +04:00
if options.uuid:
guest.uuid = options.uuid
2014-01-25 05:03:30 +04:00
if options.description:
guest.description = options.description
2018-09-07 02:07:15 +03:00
if options.os_type:
guest.os.os_type = options.os_type
if options.virt_type:
guest.type = options.virt_type
if options.arch:
guest.os.arch = options.arch
if options.machine:
guest.os.machine = options.machine
2019-02-08 00:26:04 +03:00
# If explicit os-variant requested, set it early since it will
# provide more defaults in the future
options.os_variant.set_os_name(guest)
2013-03-18 01:06:52 +04:00
2019-02-07 22:51:28 +03:00
cli.parse_option_strings(options, guest, None)
# Call set_capabilities_defaults explicitly here rather than depend
# on set_defaults calling it. Installer setup needs filled in values.
# However we want to do it after parse_option_strings to ensure
# we are operating on any arch/os/type values passed in with --boot
2018-12-10 12:36:16 +03:00
guest.set_capabilities_defaults()
installer = build_installer(options, guest)
2019-06-11 18:54:02 +03:00
set_cli_defaults(options, guest)
2018-12-10 12:36:16 +03:00
2019-02-07 23:00:27 +03:00
if installer:
installer.set_install_defaults(guest)
2019-06-10 21:28:42 +03:00
for path in installer.get_search_paths(guest):
cli.check_path_search(guest.conn, path)
2019-02-07 23:00:27 +03:00
2018-09-07 02:07:15 +03:00
# cli specific disk validation
2018-03-21 00:23:34 +03:00
for disk in guest.devices.disk:
2014-02-05 01:16:39 +04:00
cli.validate_disk(disk)
2018-09-13 00:23:01 +03:00
validate_required_options(options, guest, installer)
2018-09-03 22:21:11 +03:00
check_option_collisions(options, guest, installer)
show_warnings(options, guest, installer)
2013-03-18 01:06:52 +04:00
2018-09-03 22:21:11 +03:00
return guest, installer
2013-03-18 01:06:52 +04:00
###########################
# Install process helpers #
###########################
2018-09-03 22:21:11 +03:00
def start_install(guest, installer, options):
2017-01-18 15:11:43 +03:00
if options.wait is not None:
2013-03-18 01:06:52 +04:00
wait_on_install = True
wait_time = options.wait * 60
virtinst: guest: drop 'continue_install' concept
continue_install is intended to facilitate windows XP style 3 stage
installs:
stage 1: initial dos style disk setup, reboot
stage 2: actual full installer, reboot
stage 3: OS is functional, virt-install is done
The code assumed that we needed to keep the cdrom as the primary
boot device for the second stage, so virt-install/virt-manager needed
to hang around through the second stage run, wait until the VM shutdown,
then encode the final XML to boot of the disk.
Windows is and always has been smart enough to handle that case though...
after the initial boot, if we set the hd as the primary boot device
for stage 2, the disk bits that windows already installed will make
use of the cdrom as necessary. So the entire premise of continue_install
is irrelevant. Maybe back when it was added, when xen didn't even have
working ACPI support, this served a purpose, but I'm pretty sure we
can safely drop it nowadays.
2016-06-16 23:13:54 +03:00
else:
wait_on_install = False
wait_time = -1
2013-03-18 01:06:52 +04:00
# 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
2014-09-21 02:20:41 +04:00
if wait_time == 0:
# --wait 0 implies --noautoconsole
autoconsole = False
else:
autoconsole = options.autoconsole
conscb = None
if autoconsole:
conscb = cli.get_console_cb(guest)
if not conscb:
# If there isn't any console to actually connect up,
# default to --wait -1 to get similarish behavior
autoconsole = False
if options.wait is None:
logging.warning(_("No console to launch for the guest, "
"defaulting to --wait -1"))
wait_on_install = True
wait_time = -1
2013-03-18 01:06:52 +04:00
2015-04-12 02:25:46 +03:00
meter = cli.get_meter()
2013-03-18 01:06:52 +04:00
logging.debug("Guest.has_install_phase: %s",
2018-09-03 22:21:11 +03:00
installer.has_install_phase())
2013-03-18 01:06:52 +04:00
# we've got everything -- try to start the install
print_stdout(_("\nStarting install..."))
2018-09-03 20:41:39 +03:00
domain = None
2013-03-18 01:06:52 +04:00
try:
start_time = time.time()
2018-09-03 22:21:11 +03:00
domain = installer.start_install(guest, meter=meter,
2018-09-03 20:45:09 +03:00
doboot=not options.noreboot,
2018-10-13 16:42:15 +03:00
transient=options.transient)
2018-10-11 21:11:37 +03:00
if options.destroy_on_exit:
atexit.register(_destroy_on_exit, domain)
cli.connect_console(guest, domain, conscb, wait_on_console,
options.destroy_on_exit)
2018-09-03 22:21:11 +03:00
check_domain(installer, domain, conscb, options.transient,
2016-06-17 18:43:41 +03:00
wait_on_install, wait_time, start_time)
2013-03-18 01:06:52 +04:00
2015-03-26 23:43:28 +03:00
print_stdout(_("Domain creation completed."))
2018-09-03 20:41:39 +03:00
if not options.transient and not domain.isActive():
2018-09-03 22:21:11 +03:00
if options.noreboot or not installer.has_install_phase():
2019-06-11 01:13:31 +03:00
print_stdout( # pragma: no cover
2015-03-26 23:43:28 +03:00
_("You can restart your domain by running:\n %s") %
cli.virsh_start_cmd(guest))
else:
print_stdout(_("Restarting guest."))
2018-09-03 20:41:39 +03:00
domain.create()
2018-10-11 21:11:37 +03:00
cli.connect_console(guest, domain, conscb, True,
options.destroy_on_exit)
2013-03-18 01:06:52 +04:00
2019-06-11 01:13:31 +03:00
except KeyboardInterrupt: # pragma: no cover
2013-03-18 01:06:52 +04:00
logging.debug("", exc_info=True)
print_stderr(_("Domain install interrupted."))
raise
2017-05-05 19:47:21 +03:00
except Exception as e:
2013-03-18 01:06:52 +04:00
fail(e, do_exit=False)
2018-09-03 20:41:39 +03:00
if domain is None:
2018-09-03 22:21:11 +03:00
installer.cleanup_created_disks(guest, meter)
2013-03-18 01:06:52 +04:00
cli.install_fail(guest)
2019-06-11 01:13:31 +03:00
if cli.in_testsuite() and options.destroy_on_exit:
# Helps with unit testing
_destroy_on_exit(domain)
2013-04-13 22:34:52 +04:00
2018-09-03 22:21:11 +03:00
def check_domain(installer, domain, conscb, transient,
2016-06-01 16:32:56 +03:00
wait_for_install, wait_time, start_time):
2013-03-18 01:06:52 +04:00
"""
Make sure domain ends up in expected state, and wait if for install
to complete if requested
"""
2016-06-17 19:12:17 +03:00
def check_domain_inactive():
2016-06-01 16:32:56 +03:00
try:
2018-09-03 20:41:39 +03:00
dominfo = domain.info()
2016-06-01 16:32:56 +03:00
state = dominfo[0]
logging.debug("Domain state after install: %s", state)
2013-03-18 01:06:52 +04:00
2016-06-01 16:32:56 +03:00
if state == libvirt.VIR_DOMAIN_CRASHED:
2019-06-11 01:13:31 +03:00
fail(_("Domain has crashed.")) # pragma: no cover
2013-03-18 01:06:52 +04:00
2018-09-03 20:41:39 +03:00
return not domain.isActive()
2017-05-05 19:47:21 +03:00
except libvirt.libvirtError as e:
2016-06-01 16:32:56 +03:00
if transient and e.get_error_code() == libvirt.VIR_ERR_NO_DOMAIN:
logging.debug("transient VM shutdown and disappeared.")
return True
2019-06-11 01:13:31 +03:00
raise # pragma: no cover
2013-03-18 01:06:52 +04:00
2016-06-17 19:12:17 +03:00
if check_domain_inactive():
2016-06-17 18:43:41 +03:00
return
2013-03-18 01:06:52 +04:00
2016-06-17 19:12:17 +03:00
if bool(conscb):
# We are trying to detect if the VM shutdown, or the user
# just closed the console and the VM is still running. In the
# the former case, libvirt may not have caught up yet with the
# VM having exited, so wait a bit and check again
2018-10-11 21:11:37 +03:00
if not cli.in_testsuite():
2019-06-11 01:13:31 +03:00
time.sleep(2) # pragma: no cover
2016-06-17 19:12:17 +03:00
if check_domain_inactive():
2019-06-11 01:13:31 +03:00
return # pragma: no cover
2013-03-18 01:06:52 +04:00
2016-06-17 19:12:17 +03:00
# If we reach here, the VM still appears to be running.
2013-03-18 01:06:52 +04:00
if not wait_for_install or wait_time == 0:
# User either:
# used --noautoconsole
# used --wait 0
# killed console and guest is still running
2018-09-03 22:21:11 +03:00
if not installer.has_install_phase():
2016-06-17 18:43:41 +03:00
return
2013-03-18 01:06:52 +04:00
print_stdout(
_("Domain installation still in progress. You can reconnect"
" to \nthe console to complete the installation process."))
sys.exit(0)
2016-06-17 18:43:41 +03:00
wait_forever = (wait_time < 0)
2013-03-18 01:06:52 +04:00
timestr = (not wait_forever and
2014-09-21 02:20:41 +04:00
_(" %d minutes") % (int(wait_time) / 60) or "")
2013-03-18 01:06:52 +04:00
print_stdout(
2014-09-21 02:20:41 +04:00
_("Domain installation still in progress. Waiting"
2013-09-20 20:10:34 +04:00
"%(time_string)s for installation to complete.") %
{"time_string": timestr})
2013-03-18 01:06:52 +04:00
# Wait loop
while True:
2019-06-11 01:13:31 +03:00
if not domain.isActive(): # pragma: no cover
2016-06-17 19:12:17 +03:00
print_stdout(_("Domain has shutdown. Continuing."))
break
2019-06-11 01:13:31 +03:00
if not cli.in_testsuite(): # pragma: no cover
2018-10-11 19:14:19 +03:00
time.sleep(1)
2018-02-23 04:21:42 +03:00
2013-03-18 01:06:52 +04:00
time_elapsed = (time.time() - start_time)
2019-06-11 01:13:31 +03:00
if not cli.in_testsuite(): # pragma: no cover
2018-10-11 19:14:19 +03:00
if wait_forever:
continue
if time_elapsed < wait_time:
continue
print_stdout(
_("Installation has exceeded specified time limit. "
"Exiting application."))
sys.exit(1)
2013-03-18 01:06:52 +04:00
########################
# XML printing helpers #
########################
2018-09-03 22:21:11 +03:00
def xml_to_print(guest, installer, xmlonly, dry):
start_xml, final_xml = installer.start_install(
guest, dry=dry, return_xml=True)
2013-03-18 01:06:52 +04:00
if not start_xml:
start_xml = final_xml
final_xml = None
2015-04-05 00:10:45 +03:00
if dry and not xmlonly:
2013-03-18 01:06:52 +04:00
print_stdout(_("Dry run completed successfully"))
return
virtinst: guest: drop 'continue_install' concept
continue_install is intended to facilitate windows XP style 3 stage
installs:
stage 1: initial dos style disk setup, reboot
stage 2: actual full installer, reboot
stage 3: OS is functional, virt-install is done
The code assumed that we needed to keep the cdrom as the primary
boot device for the second stage, so virt-install/virt-manager needed
to hang around through the second stage run, wait until the VM shutdown,
then encode the final XML to boot of the disk.
Windows is and always has been smart enough to handle that case though...
after the initial boot, if we set the hd as the primary boot device
for stage 2, the disk bits that windows already installed will make
use of the cdrom as necessary. So the entire premise of continue_install
is irrelevant. Maybe back when it was added, when xen didn't even have
working ACPI support, this served a purpose, but I'm pretty sure we
can safely drop it nowadays.
2016-06-16 23:13:54 +03:00
if xmlonly not in [False, "1", "2", "all"]:
fail(_("Unknown XML step request '%s', must be 1, 2, or all") %
xmlonly)
2015-04-05 00:10:45 +03:00
if xmlonly == "1":
2013-03-18 01:06:52 +04:00
return start_xml
2015-04-05 00:10:45 +03:00
if xmlonly == "2":
virtinst: guest: drop 'continue_install' concept
continue_install is intended to facilitate windows XP style 3 stage
installs:
stage 1: initial dos style disk setup, reboot
stage 2: actual full installer, reboot
stage 3: OS is functional, virt-install is done
The code assumed that we needed to keep the cdrom as the primary
boot device for the second stage, so virt-install/virt-manager needed
to hang around through the second stage run, wait until the VM shutdown,
then encode the final XML to boot of the disk.
Windows is and always has been smart enough to handle that case though...
after the initial boot, if we set the hd as the primary boot device
for stage 2, the disk bits that windows already installed will make
use of the cdrom as necessary. So the entire premise of continue_install
is irrelevant. Maybe back when it was added, when xen didn't even have
working ACPI support, this served a purpose, but I'm pretty sure we
can safely drop it nowadays.
2016-06-16 23:13:54 +03:00
if not final_xml:
2013-03-18 01:06:52 +04:00
fail(_("Requested installation does not have XML step 2"))
return final_xml
# "all" case
xml = start_xml
if final_xml:
xml += final_xml
return xml
#######################
# CLI option handling #
#######################
def parse_args():
2013-06-30 23:03:53 +04:00
parser = cli.setupParser(
2016-04-07 22:52:07 +03:00
"%(prog)s --name NAME --memory MB STORAGE INSTALL [options]",
2014-01-22 18:06:35 +04:00
_("Create a new virtual machine from specified install media."),
introspection_epilog=True)
2013-03-18 01:06:52 +04:00
cli.add_connect_option(parser)
2014-01-19 02:01:43 +04:00
geng = parser.add_argument_group(_("General Options"))
2014-01-21 03:04:23 +04:00
geng.add_argument("-n", "--name",
2013-03-18 01:06:52 +04:00
help=_("Name of the guest instance"))
2014-01-25 03:56:59 +04:00
cli.add_memory_option(geng, backcompat=True)
2013-03-18 01:06:52 +04:00
cli.vcpu_cli_options(geng)
2014-01-25 05:03:30 +04:00
cli.add_metadata_option(geng)
geng.add_argument("-u", "--uuid", help=argparse.SUPPRESS)
geng.add_argument("--description", help=argparse.SUPPRESS)
2013-03-18 01:06:52 +04:00
2014-01-19 02:01:43 +04:00
insg = parser.add_argument_group(_("Installation Method Options"))
insg.add_argument("-c", dest="cdrom_short", help=argparse.SUPPRESS)
2014-01-21 03:04:23 +04:00
insg.add_argument("--cdrom", help=_("CD-ROM installation media"))
insg.add_argument("-l", "--location",
2018-06-12 20:49:25 +03:00
help=_("Distro install URL, eg. https://host/path. See man "
"page for specific distro examples."))
2014-01-21 03:04:23 +04:00
insg.add_argument("--pxe", action="store_true",
2013-03-18 01:06:52 +04:00
help=_("Boot from the network using the PXE protocol"))
2014-01-19 02:01:43 +04:00
insg.add_argument("--import", action="store_true", dest="import_install",
2013-03-18 01:06:52 +04:00
help=_("Build guest around an existing disk image"))
2014-01-21 03:04:23 +04:00
insg.add_argument("--livecd", action="store_true",
2013-03-18 01:06:52 +04:00
help=_("Treat the CD-ROM media as a Live CD"))
2016-03-18 05:28:17 +03:00
insg.add_argument("-x", "--extra-args", action="append",
2013-03-18 01:06:52 +04:00
help=_("Additional arguments to pass to the install kernel "
"booted from --location"))
2014-01-21 03:04:23 +04:00
insg.add_argument("--initrd-inject", action="append",
2013-03-18 01:06:52 +04:00
help=_("Add given file to root of initrd from --location"))
2019-06-11 22:18:47 +03:00
insg.add_argument("--unattended", nargs="?", const=1,
2019-02-22 11:40:08 +03:00
help=_("Perform a unattended installation"))
2014-09-07 19:57:04 +04:00
2014-09-21 04:32:19 +04:00
# Takes a URL and just prints to stdout the detected distro name
insg.add_argument("--test-media-detection", help=argparse.SUPPRESS)
2018-06-12 17:50:36 +03:00
# Helper for cli testing, fills in standard stub options
insg.add_argument("--test-stub-command", action="store_true",
help=argparse.SUPPRESS)
2014-09-21 04:32:19 +04:00
2014-02-11 03:13:42 +04:00
cli.add_boot_options(insg)
2014-01-22 00:36:34 +04:00
insg.add_argument("--init", help=argparse.SUPPRESS)
2013-03-18 01:06:52 +04:00
2019-01-08 20:44:53 +03:00
osg = cli.add_os_variant_option(parser, virtinstall=True)
2019-02-07 23:48:40 +03:00
osg.add_argument("--os-type", dest="old_os_type", help=argparse.SUPPRESS)
2013-03-18 01:06:52 +04:00
2014-09-21 03:30:16 +04:00
devg = parser.add_argument_group(_("Device Options"))
cli.add_disk_option(devg)
cli.add_net_option(devg)
cli.add_gfx_option(devg)
cli.add_device_options(devg, sound_back_compat=True)
# Deprecated device options
devg.add_argument("-f", "--file", dest="file_paths", action="append",
2014-01-19 02:01:43 +04:00
help=argparse.SUPPRESS)
2014-09-21 03:30:16 +04:00
devg.add_argument("-s", "--file-size", type=float,
2013-03-18 01:06:52 +04:00
action="append", dest="disksize",
2014-01-19 02:01:43 +04:00
help=argparse.SUPPRESS)
2014-09-21 03:30:16 +04:00
devg.add_argument("--nonsparse", action="store_false",
2013-03-18 01:06:52 +04:00
default=True, dest="sparse",
2014-01-19 02:01:43 +04:00
help=argparse.SUPPRESS)
2014-09-21 03:30:16 +04:00
devg.add_argument("--nodisks", action="store_true", help=argparse.SUPPRESS)
devg.add_argument("--nonetworks", action="store_true",
2014-09-21 02:56:39 +04:00
help=argparse.SUPPRESS)
2014-09-21 03:30:16 +04:00
devg.add_argument("-b", "--bridge", action="append",
2014-09-20 04:31:22 +04:00
help=argparse.SUPPRESS)
2014-09-21 03:30:16 +04:00
devg.add_argument("-m", "--mac", action="append", help=argparse.SUPPRESS)
devg.add_argument("--vnc", action="store_true", help=argparse.SUPPRESS)
devg.add_argument("--vncport", type=int, help=argparse.SUPPRESS)
devg.add_argument("--vnclisten", help=argparse.SUPPRESS)
devg.add_argument("-k", "--keymap", help=argparse.SUPPRESS)
devg.add_argument("--sdl", action="store_true", help=argparse.SUPPRESS)
devg.add_argument("--nographics", action="store_true",
2014-09-20 04:31:22 +04:00
help=argparse.SUPPRESS)
2013-03-18 01:06:52 +04:00
2014-09-21 03:30:16 +04:00
gxmlg = parser.add_argument_group(_("Guest Configuration Options"))
cli.add_guest_xml_options(gxmlg)
2013-03-18 01:06:52 +04:00
2014-01-19 02:01:43 +04:00
virg = parser.add_argument_group(_("Virtualization Platform Options"))
2018-09-07 02:07:15 +03:00
ostypeg = virg.add_mutually_exclusive_group()
ostypeg.add_argument("-v", "--hvm",
action="store_const", const="hvm", dest="os_type",
help=_("This guest should be a fully virtualized guest"))
ostypeg.add_argument("-p", "--paravirt",
action="store_const", const="xen", dest="os_type",
help=_("This guest should be a paravirtualized guest"))
ostypeg.add_argument("--container",
action="store_const", const="exe", dest="os_type",
help=_("This guest should be a container guest"))
virg.add_argument("--virt-type",
help=_("Hypervisor name to use (kvm, qemu, xen, ...)"))
virg.add_argument("--arch", help=_("The CPU architecture to simulate"))
virg.add_argument("--machine", help=_("The machine type to emulate"))
virg.add_argument("--accelerate", action="store_true",
help=argparse.SUPPRESS)
2014-09-20 04:31:22 +04:00
virg.add_argument("--noapic", action="store_true",
default=False, help=argparse.SUPPRESS)
virg.add_argument("--noacpi", action="store_true",
default=False, help=argparse.SUPPRESS)
2013-03-18 01:06:52 +04:00
2014-01-19 02:01:43 +04:00
misc = parser.add_argument_group(_("Miscellaneous Options"))
2018-10-11 19:53:03 +03:00
misc.add_argument("--autostart", action="store_true", default=False,
help=_("Have domain autostart on host boot up."))
misc.add_argument("--transient", action="store_true", default=False,
2016-06-01 16:32:56 +03:00
help=_("Create a transient domain."))
2018-10-11 21:11:37 +03:00
misc.add_argument("--destroy-on-exit", action="store_true", default=False,
help=_("Force power off the domain when the console "
"viewer is closed."))
2018-10-11 19:53:03 +03:00
misc.add_argument("--wait", type=int,
help=_("Minutes to wait for install to complete."))
2013-09-28 19:27:26 +04:00
cli.add_misc_options(misc, prompt=True, printxml=True, printstep=True,
2014-02-06 04:09:26 +04:00
noreboot=True, dryrun=True, noautoconsole=True)
2013-03-18 01:06:52 +04:00
2018-12-07 11:28:49 +03:00
cli.autocomplete(parser)
2014-01-19 02:01:43 +04:00
return parser.parse_args()
2013-03-18 01:06:52 +04:00
###################
# main() handling #
###################
2018-10-11 21:11:37 +03:00
# Catchall for destroying the VM on ex. ctrl-c
def _destroy_on_exit(domain):
try:
isactive = bool(domain and domain.isActive())
if isactive:
domain.destroy()
2019-06-11 01:13:31 +03:00
except libvirt.libvirtError as e: # pragma: no cover
2018-10-11 21:11:37 +03:00
if e.get_error_code() != libvirt.VIR_ERR_NO_DOMAIN:
logging.debug("Error invoking atexit destroy_on_exit",
exc_info=True)
2019-06-11 01:13:31 +03:00
def set_test_stub_options(options): # pragma: no cover
2018-06-12 17:50:36 +03:00
# Set some basic options that will let virt-install succeed. Helps
# save boiler plate typing when testing new command line additions
if not options.test_stub_command:
return
if not options.connect:
options.connect = "test:///default"
if not options.name:
options.name = "test-stub-command"
if not options.memory:
options.memory = "256"
if not options.disk:
options.disk = "none"
if not install_specified(options):
options.import_install = True
if not options.graphics:
options.graphics = "none"
2019-02-07 23:48:40 +03:00
if not options.os_variant:
options.os_variant = "fedora27"
2018-06-12 17:50:36 +03:00
2013-03-18 01:06:52 +04:00
def main(conn=None):
cli.earlyLogging()
2014-01-19 02:01:43 +04:00
options = parse_args()
2013-03-18 01:06:52 +04:00
# Default setup options
2018-06-05 21:54:34 +03:00
convert_old_printxml(options)
2015-04-05 00:10:45 +03:00
options.quiet = (options.xmlonly or
2014-09-21 04:32:19 +04:00
options.test_media_detection or options.quiet)
2013-03-18 01:06:52 +04:00
cli.setupLogging("virt-install", options.debug, options.quiet)
2018-06-05 21:54:34 +03:00
if cli.check_option_introspection(options):
return 0
2013-03-18 01:06:52 +04:00
2018-06-05 21:54:34 +03:00
check_cdrom_option_error(options)
2015-04-12 02:25:46 +03:00
cli.convert_old_force(options)
cli.parse_check(options.check)
2013-03-18 01:06:52 +04:00
cli.set_prompt(options.prompt)
2018-06-05 21:54:34 +03:00
convert_old_memory(options)
convert_old_sound(options)
convert_old_networks(options)
convert_old_graphics(options)
convert_old_disks(options)
convert_old_features(options)
convert_old_cpuset(options)
convert_old_init(options)
2018-06-12 17:50:36 +03:00
set_test_stub_options(options)
2018-06-05 21:54:34 +03:00
convert_old_os_options(options)
2014-01-22 18:06:35 +04:00
2019-06-11 01:13:31 +03:00
conn = cli.getConnection(options.connect, conn=conn)
2013-03-18 01:06:52 +04:00
2014-09-21 04:32:19 +04:00
if options.test_media_detection:
2018-09-07 03:28:05 +03:00
do_test_media_detection(conn, options)
2014-09-21 04:32:19 +04:00
return 0
2018-09-03 22:21:11 +03:00
guest, installer = build_guest_instance(conn, options)
2015-04-05 00:10:45 +03:00
if options.xmlonly or options.dry:
2018-09-03 22:21:11 +03:00
xml = xml_to_print(guest, installer, options.xmlonly, options.dry)
2013-03-18 01:06:52 +04:00
if xml:
print_stdout(xml, do_force=True)
else:
2018-09-03 22:21:11 +03:00
start_install(guest, installer, options)
2013-03-18 01:06:52 +04:00
return 0
2019-06-11 01:13:31 +03:00
if __name__ == "__main__": # pragma: no cover
2013-03-18 01:06:52 +04:00
try:
sys.exit(main())
2017-05-05 19:47:21 +03:00
except SystemExit as sys_e:
2013-03-18 01:06:52 +04:00
sys.exit(sys_e.code)
except KeyboardInterrupt:
logging.debug("", exc_info=True)
print_stderr(_("Installation aborted at user request"))
2017-05-05 19:47:21 +03:00
except Exception as main_e:
2013-03-18 01:06:52 +04:00
fail(main_e)