mirror of
https://github.com/virt-manager/virt-manager.git
synced 2024-12-23 17:34:21 +03:00
7ba76b5748
This is a compound option like we use elsewhere, with suboptions for maxmemory and hugepages.
165 lines
5.5 KiB
Python
Executable File
165 lines
5.5 KiB
Python
Executable File
#!/usr/bin/python -tt
|
|
#
|
|
# Create a virtual machine from an XML image description
|
|
#
|
|
# Copyright 2007 Red Hat, Inc.
|
|
# David Lutterkort <dlutter@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 argparse
|
|
import sys
|
|
|
|
import urlgrabber.progress as progress
|
|
|
|
import virtinst
|
|
import virtinst.cli as cli
|
|
from virtinst.cli import fail, print_stdout, print_stderr
|
|
from virtinst import virtimage
|
|
|
|
|
|
### Option parsing
|
|
def parse_args():
|
|
parser = cli.setupParser(
|
|
"%(prog)s image.xml [OPTIONS]",
|
|
_("Create a virtual machine from a virt-image(5) image descriptor."),
|
|
introspection_epilog=True)
|
|
cli.add_connect_option(parser)
|
|
|
|
parser.add_argument("image", metavar="image.xml", nargs='?',
|
|
help=_("virt-image(5) image descriptor"))
|
|
|
|
geng = parser.add_argument_group(_("General Options"))
|
|
geng.add_argument("-n", "--name", help=_("Name of the guest instance"))
|
|
geng.add_argument("-u", "--uuid", help=argparse.SUPPRESS)
|
|
cli.add_memory_option(geng, backcompat=True)
|
|
cli.vcpu_cli_options(geng)
|
|
cli.add_distro_options(geng)
|
|
cli.add_old_feature_options(geng)
|
|
|
|
cli.network_option_group(parser)
|
|
cli.graphics_option_group(parser)
|
|
|
|
misc = parser.add_argument_group(_("Miscellaneous Options"))
|
|
misc.add_argument("--boot", type=int,
|
|
help=_("The zero-based index of the boot record to use"))
|
|
misc.add_argument("--skip-checksum", action="store_true",
|
|
help=_("Skip disk checksum verification process"))
|
|
|
|
cli.add_misc_options(misc, prompt=True, replace=True, printxml=True,
|
|
noreboot=True)
|
|
|
|
return parser.parse_args()
|
|
|
|
|
|
def main(conn=None):
|
|
cli.earlyLogging()
|
|
options = parse_args()
|
|
|
|
options.quiet = options.xmlonly or options.quiet
|
|
cli.setupLogging("virt-image", options.debug, options.quiet)
|
|
cli.set_prompt(False)
|
|
|
|
cli.convert_old_features(options)
|
|
parsermap = cli.build_parser_map(options,
|
|
only=["memory", "vcpus", "cpu", "network", "graphics", "features"])
|
|
if cli.check_option_introspection(options, parsermap):
|
|
return 0
|
|
|
|
if not options.image:
|
|
fail(_("You need to provide an image XML descriptor"))
|
|
|
|
if conn is None:
|
|
conn = cli.getConnection(options.connect)
|
|
|
|
try:
|
|
image = virtimage.parse_file(options.image)
|
|
except RuntimeError, msg:
|
|
fail("%s '%s': %s" % (_("Cannot parse"), options.image, msg))
|
|
|
|
if options.boot is not None:
|
|
nboots = len(image.domain.boots)
|
|
if options.boot < 0 or options.boot >= nboots:
|
|
fail(_("The index for --boot must be between 0 and %d") %
|
|
(nboots - 1))
|
|
|
|
|
|
# Build the Installer instance
|
|
installer = virtimage.ImageInstaller(conn, image, boot_index=options.boot)
|
|
guest = conn.caps.build_virtinst_guest(conn, *installer.get_caps_guest())
|
|
guest.installer = installer
|
|
|
|
cli.convert_old_memory(options)
|
|
cli.convert_old_networks(guest, options, image.domain.interface)
|
|
cli.convert_old_graphics(guest, options,
|
|
default_override=bool(image.domain.graphics))
|
|
cli.convert_old_cpuset(options)
|
|
if not options.vcpus:
|
|
options.vcpus = image.domain.vcpu or ""
|
|
if not options.memory and image.domain.memory:
|
|
options.memory = image.domain.memory
|
|
|
|
guest.replace = options.replace
|
|
cli.set_os_variant(guest, options.distro_type, options.distro_variant)
|
|
|
|
cli.get_name(guest, options.name or image.name)
|
|
if options.uuid:
|
|
guest.uuid = options.uuid
|
|
|
|
cli.parse_option_strings(parsermap, options, guest, None)
|
|
|
|
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_device(virtinst.VirtualVideoDevice(guest.conn))
|
|
|
|
# we've got everything -- try to start the install
|
|
if options.xmlonly:
|
|
start_xml, final_xml = guest.start_install(return_xml=True)
|
|
print_stdout(start_xml or final_xml, do_force=True)
|
|
return 0
|
|
|
|
meter = progress.TextMeter(fo=sys.stdout)
|
|
|
|
if not options.skip_checksum:
|
|
for disk in image.storage.values():
|
|
disk.check_disk_signature(meter=meter)
|
|
|
|
try:
|
|
print_stdout("\n")
|
|
print_stdout(_("Creating guest %s...") % guest.name)
|
|
|
|
guest.start_install(meter=meter, noboot=options.noreboot)
|
|
except RuntimeError:
|
|
raise
|
|
except Exception, e:
|
|
fail(e, do_exit=False)
|
|
cli.install_fail(guest)
|
|
|
|
return 0
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
sys.exit(main())
|
|
except SystemExit, sys_e:
|
|
sys.exit(sys_e.code)
|
|
except KeyboardInterrupt:
|
|
print_stderr(_("Installation aborted at user request"))
|
|
except Exception, main_e:
|
|
fail(main_e)
|