lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 1 | #!/usr/bin/python |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 2 | """ |
| 3 | Utility classes and functions to handle Virtual Machine creation using qemu. |
| 4 | |
| 5 | @copyright: 2008-2009 Red Hat Inc. |
| 6 | """ |
| 7 | |
lmr | b635b86 | 2009-09-10 14:53:21 +0000 | [diff] [blame] | 8 | import time, socket, os, logging, fcntl, re, commands |
| 9 | import kvm_utils, kvm_subprocess |
lmr | 47a853b | 2010-02-04 13:56:48 +0000 | [diff] [blame] | 10 | from autotest_lib.client.common_lib import error |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 11 | from autotest_lib.client.bin import utils |
lmr | b635b86 | 2009-09-10 14:53:21 +0000 | [diff] [blame] | 12 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 13 | |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 14 | def get_image_filename(params, root_dir): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 15 | """ |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 16 | Generate an image path from params and root_dir. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 17 | |
| 18 | @param params: Dictionary containing the test parameters. |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 19 | @param root_dir: Base directory for relative filenames. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 20 | |
| 21 | @note: params should contain: |
| 22 | image_name -- the name of the image file, without extension |
| 23 | image_format -- the format of the image (qcow2, raw etc) |
| 24 | """ |
| 25 | image_name = params.get("image_name", "image") |
| 26 | image_format = params.get("image_format", "qcow2") |
| 27 | image_filename = "%s.%s" % (image_name, image_format) |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 28 | image_filename = kvm_utils.get_path(root_dir, image_filename) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 29 | return image_filename |
| 30 | |
| 31 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 32 | def create_image(params, root_dir): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 33 | """ |
| 34 | Create an image using qemu_image. |
| 35 | |
| 36 | @param params: Dictionary containing the test parameters. |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 37 | @param root_dir: Base directory for relative filenames. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 38 | |
| 39 | @note: params should contain: |
| 40 | image_name -- the name of the image file, without extension |
| 41 | image_format -- the format of the image (qcow2, raw etc) |
| 42 | image_size -- the requested size of the image (a string |
| 43 | qemu-img can understand, such as '10G') |
| 44 | """ |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 45 | qemu_img_cmd = kvm_utils.get_path(root_dir, params.get("qemu_img_binary", |
| 46 | "qemu-img")) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 47 | qemu_img_cmd += " create" |
| 48 | |
| 49 | format = params.get("image_format", "qcow2") |
| 50 | qemu_img_cmd += " -f %s" % format |
| 51 | |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 52 | image_filename = get_image_filename(params, root_dir) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 53 | qemu_img_cmd += " %s" % image_filename |
| 54 | |
| 55 | size = params.get("image_size", "10G") |
| 56 | qemu_img_cmd += " %s" % size |
| 57 | |
lmr | 47a853b | 2010-02-04 13:56:48 +0000 | [diff] [blame] | 58 | try: |
| 59 | utils.system(qemu_img_cmd) |
| 60 | except error.CmdError, e: |
| 61 | logging.error("Could not create image; qemu-img command failed:\n%s", |
| 62 | str(e)) |
| 63 | return None |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 64 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 65 | if not os.path.exists(image_filename): |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 66 | logging.error("Image could not be created for some reason; " |
| 67 | "qemu-img command:\n%s" % qemu_img_cmd) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 68 | return None |
| 69 | |
| 70 | logging.info("Image created in %s" % image_filename) |
| 71 | return image_filename |
| 72 | |
| 73 | |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 74 | def remove_image(params, root_dir): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 75 | """ |
| 76 | Remove an image file. |
| 77 | |
| 78 | @param params: A dict |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 79 | @param root_dir: Base directory for relative filenames. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 80 | |
| 81 | @note: params should contain: |
| 82 | image_name -- the name of the image file, without extension |
| 83 | image_format -- the format of the image (qcow2, raw etc) |
| 84 | """ |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 85 | image_filename = get_image_filename(params, root_dir) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 86 | logging.debug("Removing image file %s..." % image_filename) |
| 87 | if os.path.exists(image_filename): |
| 88 | os.unlink(image_filename) |
| 89 | else: |
| 90 | logging.debug("Image file %s not found") |
| 91 | |
| 92 | |
| 93 | class VM: |
| 94 | """ |
| 95 | This class handles all basic VM operations. |
| 96 | """ |
| 97 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 98 | def __init__(self, name, params, root_dir, address_cache): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 99 | """ |
| 100 | Initialize the object and set a few attributes. |
| 101 | |
| 102 | @param name: The name of the object |
| 103 | @param params: A dict containing VM params |
| 104 | (see method make_qemu_command for a full description) |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 105 | @param root_dir: Base directory for relative filenames |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 106 | @param address_cache: A dict that maps MAC addresses to IP addresses |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 107 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 108 | self.process = None |
lmr | 953ffba | 2009-07-27 13:20:10 +0000 | [diff] [blame] | 109 | self.redirs = {} |
| 110 | self.vnc_port = 5900 |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 111 | self.uuid = None |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 112 | |
| 113 | self.name = name |
| 114 | self.params = params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 115 | self.root_dir = root_dir |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 116 | self.address_cache = address_cache |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 117 | self.pci_assignable = None |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame^] | 118 | self.netdev_id = [] |
| 119 | for nic in params.get("nics").split(): |
| 120 | self.netdev_id.append(kvm_utils.generate_random_string(4)) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 121 | |
lmr | 8b134f9 | 2009-06-08 14:47:31 +0000 | [diff] [blame] | 122 | # Find available monitor filename |
| 123 | while True: |
| 124 | # The monitor filename should be unique |
lmr | d16a67d | 2009-06-10 19:52:59 +0000 | [diff] [blame] | 125 | self.instance = (time.strftime("%Y%m%d-%H%M%S-") + |
| 126 | kvm_utils.generate_random_string(4)) |
lmr | 8b134f9 | 2009-06-08 14:47:31 +0000 | [diff] [blame] | 127 | self.monitor_file_name = os.path.join("/tmp", |
| 128 | "monitor-" + self.instance) |
| 129 | if not os.path.exists(self.monitor_file_name): |
| 130 | break |
| 131 | |
| 132 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 133 | def clone(self, name=None, params=None, root_dir=None, address_cache=None): |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 134 | """ |
| 135 | Return a clone of the VM object with optionally modified parameters. |
| 136 | The clone is initially not alive and needs to be started using create(). |
| 137 | Any parameters not passed to this function are copied from the source |
| 138 | VM. |
| 139 | |
| 140 | @param name: Optional new VM name |
| 141 | @param params: Optional new VM creation parameters |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 142 | @param root_dir: Optional new base directory for relative filenames |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 143 | @param address_cache: A dict that maps MAC addresses to IP addresses |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 144 | """ |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 145 | if name is None: |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 146 | name = self.name |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 147 | if params is None: |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 148 | params = self.params.copy() |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 149 | if root_dir is None: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 150 | root_dir = self.root_dir |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 151 | if address_cache is None: |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 152 | address_cache = self.address_cache |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 153 | return VM(name, params, root_dir, address_cache) |
lmr | 2c24117 | 2009-06-08 15:11:29 +0000 | [diff] [blame] | 154 | |
| 155 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 156 | def make_qemu_command(self, name=None, params=None, root_dir=None): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 157 | """ |
| 158 | Generate a qemu command line. All parameters are optional. If a |
| 159 | parameter is not supplied, the corresponding value stored in the |
| 160 | class attributes is used. |
| 161 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 162 | @param name: The name of the object |
| 163 | @param params: A dict containing VM params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 164 | @param root_dir: Base directory for relative filenames |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 165 | |
| 166 | @note: The params dict should contain: |
| 167 | mem -- memory size in MBs |
| 168 | cdrom -- ISO filename to use with the qemu -cdrom parameter |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 169 | extra_params -- a string to append to the qemu command |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 170 | shell_port -- port of the remote shell daemon on the guest |
| 171 | (SSH, Telnet or the home-made Remote Shell Server) |
| 172 | shell_client -- client program to use for connecting to the |
| 173 | remote shell daemon on the guest (ssh, telnet or nc) |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 174 | x11_display -- if specified, the DISPLAY environment variable |
| 175 | will be be set to this value for the qemu process (useful for |
| 176 | SDL rendering) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 177 | images -- a list of image object names, separated by spaces |
| 178 | nics -- a list of NIC object names, separated by spaces |
| 179 | |
| 180 | For each image in images: |
| 181 | drive_format -- string to pass as 'if' parameter for this |
| 182 | image (e.g. ide, scsi) |
| 183 | image_snapshot -- if yes, pass 'snapshot=on' to qemu for |
| 184 | this image |
| 185 | image_boot -- if yes, pass 'boot=on' to qemu for this image |
| 186 | In addition, all parameters required by get_image_filename. |
| 187 | |
| 188 | For each NIC in nics: |
| 189 | nic_model -- string to pass as 'model' parameter for this |
| 190 | NIC (e.g. e1000) |
| 191 | """ |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 192 | # Helper function for command line option wrappers |
| 193 | def has_option(help, option): |
| 194 | return bool(re.search(r"^-%s(\s|$)" % option, help, re.MULTILINE)) |
| 195 | |
| 196 | # Wrappers for all supported qemu command line parameters. |
| 197 | # This is meant to allow support for multiple qemu versions. |
| 198 | # Each of these functions receives the output of 'qemu -help' as a |
| 199 | # parameter, and should add the requested command line option |
| 200 | # accordingly. |
| 201 | |
| 202 | def add_name(help, name): |
| 203 | return " -name '%s'" % name |
| 204 | |
| 205 | def add_unix_socket_monitor(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 206 | return " -monitor unix:'%s',server,nowait" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 207 | |
| 208 | def add_mem(help, mem): |
| 209 | return " -m %s" % mem |
| 210 | |
| 211 | def add_smp(help, smp): |
| 212 | return " -smp %s" % smp |
| 213 | |
| 214 | def add_cdrom(help, filename, index=2): |
| 215 | if has_option(help, "drive"): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 216 | return " -drive file='%s',index=%d,media=cdrom" % (filename, |
| 217 | index) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 218 | else: |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 219 | return " -cdrom '%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 220 | |
| 221 | def add_drive(help, filename, format=None, cache=None, werror=None, |
| 222 | serial=None, snapshot=False, boot=False): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 223 | cmd = " -drive file='%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 224 | if format: cmd += ",if=%s" % format |
| 225 | if cache: cmd += ",cache=%s" % cache |
| 226 | if werror: cmd += ",werror=%s" % werror |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 227 | if serial: cmd += ",serial='%s'" % serial |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 228 | if snapshot: cmd += ",snapshot=on" |
| 229 | if boot: cmd += ",boot=on" |
| 230 | return cmd |
| 231 | |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame^] | 232 | def add_nic(help, vlan, model=None, mac=None, netdev_id=None): |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 233 | cmd = " -net nic,vlan=%d" % vlan |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame^] | 234 | if has_option(help, "netdev"): |
| 235 | cmd +=",netdev=%s" % netdev_id |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 236 | if model: cmd += ",model=%s" % model |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 237 | if mac: cmd += ",macaddr='%s'" % mac |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 238 | return cmd |
| 239 | |
| 240 | def add_net(help, vlan, mode, ifname=None, script=None, |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame^] | 241 | downscript=None, netdev_id=None): |
| 242 | if has_option(help, "netdev"): |
| 243 | cmd = " -netdev %s,id=%s" % (mode, netdev_id) |
| 244 | else: |
| 245 | cmd = " -net %s,vlan=%d" % (mode, vlan) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 246 | if mode == "tap": |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 247 | if ifname: cmd += ",ifname='%s'" % ifname |
| 248 | if script: cmd += ",script='%s'" % script |
| 249 | cmd += ",downscript='%s'" % (downscript or "no") |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 250 | return cmd |
| 251 | |
| 252 | def add_floppy(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 253 | return " -fda '%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 254 | |
| 255 | def add_tftp(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 256 | return " -tftp '%s'" % filename |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 257 | |
| 258 | def add_tcp_redir(help, host_port, guest_port): |
| 259 | return " -redir tcp:%s::%s" % (host_port, guest_port) |
| 260 | |
| 261 | def add_vnc(help, vnc_port): |
| 262 | return " -vnc :%d" % (vnc_port - 5900) |
| 263 | |
| 264 | def add_sdl(help): |
| 265 | if has_option(help, "sdl"): |
| 266 | return " -sdl" |
| 267 | else: |
| 268 | return "" |
| 269 | |
| 270 | def add_nographic(help): |
| 271 | return " -nographic" |
| 272 | |
| 273 | def add_uuid(help, uuid): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 274 | return " -uuid '%s'" % uuid |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 275 | |
| 276 | def add_pcidevice(help, host): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 277 | return " -pcidevice host='%s'" % host |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 278 | |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 279 | def add_kernel(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 280 | return " -kernel '%s'" % filename |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 281 | |
| 282 | def add_initrd(help, filename): |
lmr | 09a7816 | 2010-06-14 16:29:23 +0000 | [diff] [blame] | 283 | return " -initrd '%s'" % filename |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 284 | |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 285 | # End of command line option wrappers |
| 286 | |
| 287 | if name is None: name = self.name |
| 288 | if params is None: params = self.params |
| 289 | if root_dir is None: root_dir = self.root_dir |
| 290 | |
| 291 | qemu_binary = kvm_utils.get_path(root_dir, params.get("qemu_binary", |
| 292 | "qemu")) |
| 293 | # Get the output of 'qemu -help' (log a message in case this call never |
| 294 | # returns or causes some other kind of trouble) |
| 295 | logging.debug("Getting output of 'qemu -help'") |
| 296 | help = commands.getoutput("%s -help" % qemu_binary) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 297 | |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 298 | # Start constructing the qemu command |
| 299 | qemu_cmd = "" |
| 300 | # Set the X11 display parameter if requested |
| 301 | if params.get("x11_display"): |
| 302 | qemu_cmd += "DISPLAY=%s " % params.get("x11_display") |
| 303 | # Add the qemu binary |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 304 | qemu_cmd += qemu_binary |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 305 | # Add the VM's name |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 306 | qemu_cmd += add_name(help, name) |
lmr | eeff0eb | 2009-06-10 19:19:15 +0000 | [diff] [blame] | 307 | # Add the monitor socket parameter |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 308 | qemu_cmd += add_unix_socket_monitor(help, self.monitor_file_name) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 309 | |
| 310 | for image_name in kvm_utils.get_sub_dict_names(params, "images"): |
| 311 | image_params = kvm_utils.get_sub_dict(params, image_name) |
lmr | 9d75ee3 | 2009-09-29 13:14:13 +0000 | [diff] [blame] | 312 | if image_params.get("boot_drive") == "no": |
| 313 | continue |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 314 | qemu_cmd += add_drive(help, |
| 315 | get_image_filename(image_params, root_dir), |
| 316 | image_params.get("drive_format"), |
| 317 | image_params.get("drive_cache"), |
| 318 | image_params.get("drive_werror"), |
| 319 | image_params.get("drive_serial"), |
| 320 | image_params.get("image_snapshot") == "yes", |
| 321 | image_params.get("image_boot") == "yes") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 322 | |
| 323 | vlan = 0 |
| 324 | for nic_name in kvm_utils.get_sub_dict_names(params, "nics"): |
| 325 | nic_params = kvm_utils.get_sub_dict(params, nic_name) |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 326 | # Handle the '-net nic' part |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 327 | mac = None |
| 328 | if "address_index" in nic_params: |
| 329 | mac = kvm_utils.get_mac_ip_pair_from_dict(nic_params)[0] |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame^] | 330 | qemu_cmd += add_nic(help, vlan, nic_params.get("nic_model"), mac, |
| 331 | self.netdev_id[vlan]) |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 332 | # Handle the '-net tap' or '-net user' part |
lmr | e4eaa86 | 2010-06-01 19:15:14 +0000 | [diff] [blame] | 333 | script = nic_params.get("nic_script") |
| 334 | downscript = nic_params.get("nic_downscript") |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 335 | if script: |
| 336 | script = kvm_utils.get_path(root_dir, script) |
| 337 | if downscript: |
| 338 | downscript = kvm_utils.get_path(root_dir, downscript) |
| 339 | qemu_cmd += add_net(help, vlan, nic_params.get("nic_mode", "user"), |
| 340 | nic_params.get("nic_ifname"), |
lmr | b1cad1e | 2010-06-17 17:36:09 +0000 | [diff] [blame^] | 341 | script, downscript, self.netdev_id[vlan]) |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 342 | # Proceed to next NIC |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 343 | vlan += 1 |
| 344 | |
| 345 | mem = params.get("mem") |
| 346 | if mem: |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 347 | qemu_cmd += add_mem(help, mem) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 348 | |
lmr | c43bf37 | 2009-11-10 13:19:00 +0000 | [diff] [blame] | 349 | smp = params.get("smp") |
| 350 | if smp: |
lmr | db3fe61 | 2010-06-14 16:19:28 +0000 | [diff] [blame] | 351 | qemu_cmd += add_smp(help, smp) |
lmr | c43bf37 | 2009-11-10 13:19:00 +0000 | [diff] [blame] | 352 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 353 | iso = params.get("cdrom") |
| 354 | if iso: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 355 | iso = kvm_utils.get_path(root_dir, iso) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 356 | qemu_cmd += add_cdrom(help, iso) |
lmr | 89fd641 | 2010-01-18 02:42:57 +0000 | [diff] [blame] | 357 | |
| 358 | # Even though this is not a really scalable approach, |
| 359 | # it doesn't seem like we are going to need more than |
| 360 | # 2 CDs active on the same VM. |
| 361 | iso_extra = params.get("cdrom_extra") |
| 362 | if iso_extra: |
| 363 | iso_extra = kvm_utils.get_path(root_dir, iso_extra) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 364 | qemu_cmd += add_cdrom(help, iso_extra, 3) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 365 | |
lmr | b0a9b76 | 2009-10-09 20:43:30 +0000 | [diff] [blame] | 366 | # We may want to add {floppy_otps} parameter for -fda |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 367 | # {fat:floppy:}/path/. However vvfat is not usually recommended. |
lmr | b0a9b76 | 2009-10-09 20:43:30 +0000 | [diff] [blame] | 368 | floppy = params.get("floppy") |
| 369 | if floppy: |
lmr | f69f6b1 | 2009-11-10 16:33:44 +0000 | [diff] [blame] | 370 | floppy = kvm_utils.get_path(root_dir, floppy) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 371 | qemu_cmd += add_floppy(help, floppy) |
lmr | b0a9b76 | 2009-10-09 20:43:30 +0000 | [diff] [blame] | 372 | |
| 373 | tftp = params.get("tftp") |
| 374 | if tftp: |
lmr | f69f6b1 | 2009-11-10 16:33:44 +0000 | [diff] [blame] | 375 | tftp = kvm_utils.get_path(root_dir, tftp) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 376 | qemu_cmd += add_tftp(help, tftp) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 377 | |
lmr | 41cb8fc | 2010-06-10 15:30:45 +0000 | [diff] [blame] | 378 | kernel = params.get("kernel") |
| 379 | if kernel: |
| 380 | kernel = kvm_utils.get_path(root_dir, kernel) |
| 381 | qemu_cmd += add_kernel(help, kernel) |
| 382 | |
| 383 | initrd = params.get("initrd") |
| 384 | if initrd: |
| 385 | initrd = kvm_utils.get_path(root_dir, initrd) |
| 386 | qemu_cmd += add_initrd(help, initrd) |
| 387 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 388 | for redir_name in kvm_utils.get_sub_dict_names(params, "redirs"): |
| 389 | redir_params = kvm_utils.get_sub_dict(params, redir_name) |
| 390 | guest_port = int(redir_params.get("guest_port")) |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 391 | host_port = self.redirs.get(guest_port) |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 392 | qemu_cmd += add_tcp_redir(help, host_port, guest_port) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 393 | |
| 394 | if params.get("display") == "vnc": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 395 | qemu_cmd += add_vnc(help, self.vnc_port) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 396 | elif params.get("display") == "sdl": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 397 | qemu_cmd += add_sdl(help) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 398 | elif params.get("display") == "nographic": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 399 | qemu_cmd += add_nographic(help) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 400 | |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 401 | if params.get("uuid") == "random": |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 402 | qemu_cmd += add_uuid(help, self.uuid) |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 403 | elif params.get("uuid"): |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 404 | qemu_cmd += add_uuid(help, params.get("uuid")) |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 405 | |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 406 | # If the PCI assignment step went OK, add each one of the PCI assigned |
| 407 | # devices to the qemu command line. |
| 408 | if self.pci_assignable: |
| 409 | for pci_id in self.pa_pci_ids: |
lmr | 48abd7d | 2010-05-26 13:48:04 +0000 | [diff] [blame] | 410 | qemu_cmd += add_pcidevice(help, pci_id) |
| 411 | |
| 412 | extra_params = params.get("extra_params") |
| 413 | if extra_params: |
| 414 | qemu_cmd += " %s" % extra_params |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 415 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 416 | return qemu_cmd |
| 417 | |
| 418 | |
lmr | 52800ba | 2009-08-17 20:49:58 +0000 | [diff] [blame] | 419 | def create(self, name=None, params=None, root_dir=None, |
lmr | 1424f3e | 2010-06-17 13:57:09 +0000 | [diff] [blame] | 420 | for_migration=False, timeout=5.0, extra_params=None): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 421 | """ |
| 422 | Start the VM by running a qemu command. |
| 423 | All parameters are optional. The following applies to all parameters |
| 424 | but for_migration: If a parameter is not supplied, the corresponding |
| 425 | value stored in the class attributes is used, and if it is supplied, |
| 426 | it is stored for later use. |
| 427 | |
| 428 | @param name: The name of the object |
| 429 | @param params: A dict containing VM params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 430 | @param root_dir: Base directory for relative filenames |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 431 | @param for_migration: If True, start the VM with the -incoming |
| 432 | option |
lmr | 1424f3e | 2010-06-17 13:57:09 +0000 | [diff] [blame] | 433 | @param extra_params: extra params for qemu command.e.g -incoming option |
| 434 | Please use this parameter instead of for_migration. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 435 | """ |
lmr | 135b5e6 | 2009-06-10 19:22:31 +0000 | [diff] [blame] | 436 | self.destroy() |
| 437 | |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 438 | if name is not None: |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 439 | self.name = name |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 440 | if params is not None: |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 441 | self.params = params |
lmr | e45a1f2 | 2009-11-10 16:35:08 +0000 | [diff] [blame] | 442 | if root_dir is not None: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 443 | self.root_dir = root_dir |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 444 | name = self.name |
| 445 | params = self.params |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 446 | root_dir = self.root_dir |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 447 | |
| 448 | # Verify the md5sum of the ISO image |
| 449 | iso = params.get("cdrom") |
| 450 | if iso: |
lmr | 90b9fd5 | 2009-08-17 20:48:18 +0000 | [diff] [blame] | 451 | iso = kvm_utils.get_path(root_dir, iso) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 452 | if not os.path.exists(iso): |
| 453 | logging.error("ISO file not found: %s" % iso) |
| 454 | return False |
| 455 | compare = False |
| 456 | if params.get("md5sum_1m"): |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 457 | logging.debug("Comparing expected MD5 sum with MD5 sum of " |
| 458 | "first MB of ISO file...") |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 459 | actual_hash = utils.hash_file(iso, 1048576, method="md5") |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 460 | expected_hash = params.get("md5sum_1m") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 461 | compare = True |
| 462 | elif params.get("md5sum"): |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 463 | logging.debug("Comparing expected MD5 sum with MD5 sum of ISO " |
| 464 | "file...") |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 465 | actual_hash = utils.hash_file(iso, method="md5") |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 466 | expected_hash = params.get("md5sum") |
| 467 | compare = True |
| 468 | elif params.get("sha1sum"): |
| 469 | logging.debug("Comparing expected SHA1 sum with SHA1 sum of " |
| 470 | "ISO file...") |
lmr | d60882f | 2010-02-04 03:26:36 +0000 | [diff] [blame] | 471 | actual_hash = utils.hash_file(iso, method="sha1") |
lmr | ea1266e | 2009-11-10 16:41:08 +0000 | [diff] [blame] | 472 | expected_hash = params.get("sha1sum") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 473 | compare = True |
| 474 | if compare: |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 475 | if actual_hash == expected_hash: |
| 476 | logging.debug("Hashes match") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 477 | else: |
lmr | 03ba22e | 2009-10-23 12:07:44 +0000 | [diff] [blame] | 478 | logging.error("Actual hash differs from expected one") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 479 | return False |
| 480 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 481 | # Make sure the following code is not executed by more than one thread |
| 482 | # at the same time |
| 483 | lockfile = open("/tmp/kvm-autotest-vm-create.lock", "w+") |
| 484 | fcntl.lockf(lockfile, fcntl.LOCK_EX) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 485 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 486 | try: |
| 487 | # Handle port redirections |
| 488 | redir_names = kvm_utils.get_sub_dict_names(params, "redirs") |
| 489 | host_ports = kvm_utils.find_free_ports(5000, 6000, len(redir_names)) |
| 490 | self.redirs = {} |
| 491 | for i in range(len(redir_names)): |
| 492 | redir_params = kvm_utils.get_sub_dict(params, redir_names[i]) |
| 493 | guest_port = int(redir_params.get("guest_port")) |
| 494 | self.redirs[guest_port] = host_ports[i] |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 495 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 496 | # Find available VNC port, if needed |
| 497 | if params.get("display") == "vnc": |
lmr | c0da890 | 2010-05-17 20:31:36 +0000 | [diff] [blame] | 498 | self.vnc_port = kvm_utils.find_free_port(5900, 6100) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 499 | |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 500 | # Find random UUID if specified 'uuid = random' in config file |
| 501 | if params.get("uuid") == "random": |
| 502 | f = open("/proc/sys/kernel/random/uuid") |
| 503 | self.uuid = f.read().strip() |
| 504 | f.close() |
| 505 | |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 506 | # Assign a PCI assignable device |
| 507 | self.pci_assignable = None |
| 508 | pa_type = params.get("pci_assignable") |
| 509 | if pa_type in ["vf", "pf", "mixed"]: |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 510 | pa_devices_requested = params.get("devices_requested") |
| 511 | |
| 512 | # Virtual Functions (VF) assignable devices |
| 513 | if pa_type == "vf": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 514 | self.pci_assignable = kvm_utils.PciAssignable( |
| 515 | type=pa_type, |
| 516 | driver=params.get("driver"), |
| 517 | driver_option=params.get("driver_option"), |
| 518 | devices_requested=pa_devices_requested) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 519 | # Physical NIC (PF) assignable devices |
| 520 | elif pa_type == "pf": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 521 | self.pci_assignable = kvm_utils.PciAssignable( |
| 522 | type=pa_type, |
| 523 | names=params.get("device_names"), |
| 524 | devices_requested=pa_devices_requested) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 525 | # Working with both VF and PF |
| 526 | elif pa_type == "mixed": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 527 | self.pci_assignable = kvm_utils.PciAssignable( |
| 528 | type=pa_type, |
| 529 | driver=params.get("driver"), |
| 530 | driver_option=params.get("driver_option"), |
| 531 | names=params.get("device_names"), |
| 532 | devices_requested=pa_devices_requested) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 533 | |
| 534 | self.pa_pci_ids = self.pci_assignable.request_devs() |
| 535 | |
| 536 | if self.pa_pci_ids: |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 537 | logging.debug("Successfuly assigned devices: %s", |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 538 | self.pa_pci_ids) |
| 539 | else: |
| 540 | logging.error("No PCI assignable devices were assigned " |
| 541 | "and 'pci_assignable' is defined to %s " |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 542 | "on your config file. Aborting VM creation.", |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 543 | pa_type) |
| 544 | return False |
| 545 | |
lmr | 856d58c | 2010-06-08 18:29:31 +0000 | [diff] [blame] | 546 | elif pa_type and pa_type != "no": |
lmr | 31ed61d | 2010-06-07 13:21:38 +0000 | [diff] [blame] | 547 | logging.warn("Unsupported pci_assignable type: %s", pa_type) |
lmr | 31af3a1 | 2010-01-18 16:46:52 +0000 | [diff] [blame] | 548 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 549 | # Make qemu command |
| 550 | qemu_command = self.make_qemu_command() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 551 | |
lmr | 1424f3e | 2010-06-17 13:57:09 +0000 | [diff] [blame] | 552 | # Enable migration support for VM by adding extra_params. |
| 553 | if extra_params is not None: |
| 554 | if " -incoming tcp:0:%d" == extra_params: |
| 555 | self.migration_port = kvm_utils.find_free_port(5200, 6000) |
| 556 | qemu_command += extra_params % self.migration_port |
| 557 | elif " -incoming unix:%s" == extra_params: |
| 558 | self.migration_file = os.path.join("/tmp/", "unix-" + |
| 559 | time.strftime("%Y%m%d-%H%M%S")) |
| 560 | qemu_command += extra_params % self.migration_file |
| 561 | else: |
| 562 | qemu_command += extra_params |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 563 | |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 564 | logging.debug("Running qemu command:\n%s", qemu_command) |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 565 | self.process = kvm_subprocess.run_bg(qemu_command, None, |
| 566 | logging.debug, "(qemu) ") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 567 | |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 568 | if not self.process.is_alive(): |
| 569 | logging.error("VM could not be created; " |
| 570 | "qemu command failed:\n%s" % qemu_command) |
| 571 | logging.error("Status: %s" % self.process.get_status()) |
| 572 | logging.error("Output:" + kvm_utils.format_str_for_message( |
| 573 | self.process.get_output())) |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 574 | self.destroy() |
| 575 | return False |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 576 | |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 577 | if not kvm_utils.wait_for(self.is_alive, timeout, 0, 1): |
| 578 | logging.error("VM is not alive for some reason; " |
| 579 | "qemu command:\n%s" % qemu_command) |
| 580 | self.destroy() |
| 581 | return False |
| 582 | |
lmr | fe6515e | 2009-07-29 13:01:17 +0000 | [diff] [blame] | 583 | # Get the output so far, to see if we have any problems with |
| 584 | # hugepage setup. |
| 585 | output = self.process.get_output() |
| 586 | |
| 587 | if "alloc_mem_area" in output: |
| 588 | logging.error("Could not allocate hugepage memory; " |
| 589 | "qemu command:\n%s" % qemu_command) |
| 590 | logging.error("Output:" + kvm_utils.format_str_for_message( |
| 591 | self.process.get_output())) |
lmr | 090cd7a | 2010-04-01 02:18:52 +0000 | [diff] [blame] | 592 | self.destroy() |
lmr | fe6515e | 2009-07-29 13:01:17 +0000 | [diff] [blame] | 593 | return False |
| 594 | |
lmr | 71fa4de | 2010-06-14 15:54:55 +0000 | [diff] [blame] | 595 | logging.debug("VM appears to be alive with PID %s", self.get_pid()) |
lmr | dc2ac6a | 2009-06-10 19:15:49 +0000 | [diff] [blame] | 596 | return True |
| 597 | |
| 598 | finally: |
| 599 | fcntl.lockf(lockfile, fcntl.LOCK_UN) |
| 600 | lockfile.close() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 601 | |
| 602 | |
lmr | 70c1c5b | 2010-04-17 18:05:29 +0000 | [diff] [blame] | 603 | def send_monitor_cmd(self, command, block=True, timeout=20.0, verbose=True): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 604 | """ |
| 605 | Send command to the QEMU monitor. |
| 606 | |
| 607 | Connect to the VM's monitor socket and wait for the (qemu) prompt. |
| 608 | If block is True, read output from the socket until the (qemu) prompt |
| 609 | is found again, or until timeout expires. |
| 610 | |
| 611 | Return a tuple containing an integer indicating success or failure, |
| 612 | and the data read so far. The integer is 0 on success and 1 on failure. |
| 613 | A failure is any of the following cases: connection to the socket |
| 614 | failed, or the first (qemu) prompt could not be found, or block is |
| 615 | True and the second prompt could not be found. |
| 616 | |
| 617 | @param command: Command that will be sent to the monitor |
| 618 | @param block: Whether the output from the socket will be read until |
| 619 | the timeout expires |
| 620 | @param timeout: Timeout (seconds) before giving up on reading from |
| 621 | socket |
| 622 | """ |
| 623 | def read_up_to_qemu_prompt(s, timeout): |
| 624 | """ |
| 625 | Read data from socket s until the (qemu) prompt is found. |
| 626 | |
| 627 | If the prompt is found before timeout expires, return a tuple |
| 628 | containing True and the data read. Otherwise return a tuple |
| 629 | containing False and the data read so far. |
| 630 | |
| 631 | @param s: Socket object |
| 632 | @param timeout: Time (seconds) before giving up trying to get the |
| 633 | qemu prompt. |
| 634 | """ |
| 635 | o = "" |
| 636 | end_time = time.time() + timeout |
| 637 | while time.time() < end_time: |
| 638 | try: |
lmr | bcd2083 | 2009-10-15 11:56:56 +0000 | [diff] [blame] | 639 | o += s.recv(1024) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 640 | if o.splitlines()[-1].split()[-1] == "(qemu)": |
| 641 | return (True, o) |
| 642 | except: |
| 643 | time.sleep(0.01) |
| 644 | return (False, o) |
| 645 | |
lmr | 70c1c5b | 2010-04-17 18:05:29 +0000 | [diff] [blame] | 646 | # In certain conditions printing this debug output might be too much |
| 647 | # Just print it if verbose is enabled (True by default) |
| 648 | if verbose: |
| 649 | logging.debug("Sending monitor command: %s" % command) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 650 | # Connect to monitor |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 651 | try: |
| 652 | s = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) |
| 653 | s.setblocking(False) |
| 654 | s.connect(self.monitor_file_name) |
| 655 | except: |
| 656 | logging.debug("Could not connect to monitor socket") |
| 657 | return (1, "") |
lmr | bcd2083 | 2009-10-15 11:56:56 +0000 | [diff] [blame] | 658 | |
| 659 | # Send the command and get the resulting output |
| 660 | try: |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 661 | status, data = read_up_to_qemu_prompt(s, timeout) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 662 | if not status: |
lmr | bcd2083 | 2009-10-15 11:56:56 +0000 | [diff] [blame] | 663 | logging.debug("Could not find (qemu) prompt; output so far:" + |
| 664 | kvm_utils.format_str_for_message(data)) |
| 665 | return (1, "") |
| 666 | # Send command |
| 667 | s.sendall(command + "\n") |
| 668 | # Receive command output |
| 669 | data = "" |
| 670 | if block: |
| 671 | status, data = read_up_to_qemu_prompt(s, timeout) |
| 672 | data = "\n".join(data.splitlines()[1:]) |
| 673 | if not status: |
| 674 | logging.debug("Could not find (qemu) prompt after command; " |
| 675 | "output so far:" + |
| 676 | kvm_utils.format_str_for_message(data)) |
| 677 | return (1, data) |
lmr | 612323d | 2010-06-17 16:48:45 +0000 | [diff] [blame] | 678 | data = "".join(data.rstrip().splitlines(True)[:-1]) |
lmr | bcd2083 | 2009-10-15 11:56:56 +0000 | [diff] [blame] | 679 | return (0, data) |
| 680 | |
| 681 | # Clean up before exiting |
| 682 | finally: |
| 683 | s.shutdown(socket.SHUT_RDWR) |
| 684 | s.close() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 685 | |
| 686 | |
| 687 | def destroy(self, gracefully=True): |
| 688 | """ |
| 689 | Destroy the VM. |
| 690 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 691 | If gracefully is True, first attempt to shutdown the VM with a shell |
| 692 | command. Then, attempt to destroy the VM via the monitor with a 'quit' |
| 693 | command. If that fails, send SIGKILL to the qemu process. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 694 | |
| 695 | @param gracefully: Whether an attempt will be made to end the VM |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 696 | using a shell command before trying to end the qemu process |
| 697 | with a 'quit' or a kill signal. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 698 | """ |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 699 | try: |
| 700 | # Is it already dead? |
| 701 | if self.is_dead(): |
| 702 | logging.debug("VM is already down") |
| 703 | return |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 704 | |
lmr | 71fa4de | 2010-06-14 15:54:55 +0000 | [diff] [blame] | 705 | logging.debug("Destroying VM with PID %s...", self.get_pid()) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 706 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 707 | if gracefully and self.params.get("shutdown_command"): |
| 708 | # Try to destroy with shell command |
| 709 | logging.debug("Trying to shutdown VM with shell command...") |
| 710 | session = self.remote_login() |
| 711 | if session: |
| 712 | try: |
| 713 | # Send the shutdown command |
| 714 | session.sendline(self.params.get("shutdown_command")) |
| 715 | logging.debug("Shutdown command sent; waiting for VM " |
| 716 | "to go down...") |
| 717 | if kvm_utils.wait_for(self.is_dead, 60, 1, 1): |
| 718 | logging.debug("VM is down") |
| 719 | return |
| 720 | finally: |
| 721 | session.close() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 722 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 723 | # Try to destroy with a monitor command |
| 724 | logging.debug("Trying to kill VM with monitor command...") |
| 725 | status, output = self.send_monitor_cmd("quit", block=False) |
| 726 | # Was the command sent successfully? |
| 727 | if status == 0: |
| 728 | # Wait for the VM to be really dead |
| 729 | if kvm_utils.wait_for(self.is_dead, 5, 0.5, 0.5): |
| 730 | logging.debug("VM is down") |
| 731 | return |
| 732 | |
| 733 | # If the VM isn't dead yet... |
| 734 | logging.debug("Cannot quit normally; sending a kill to close the " |
| 735 | "deal...") |
| 736 | kvm_utils.kill_process_tree(self.process.get_pid(), 9) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 737 | # Wait for the VM to be really dead |
| 738 | if kvm_utils.wait_for(self.is_dead, 5, 0.5, 0.5): |
| 739 | logging.debug("VM is down") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 740 | return |
| 741 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 742 | logging.error("Process %s is a zombie!" % self.process.get_pid()) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 743 | |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 744 | finally: |
lmr | 4513c43 | 2010-02-03 11:59:03 +0000 | [diff] [blame] | 745 | if self.pci_assignable: |
| 746 | self.pci_assignable.release_devs() |
lmr | f320b04 | 2009-09-15 05:48:06 +0000 | [diff] [blame] | 747 | if self.process: |
| 748 | self.process.close() |
lmr | 4dcc007 | 2009-11-10 16:52:27 +0000 | [diff] [blame] | 749 | try: |
| 750 | os.unlink(self.monitor_file_name) |
| 751 | except OSError: |
| 752 | pass |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 753 | |
| 754 | |
| 755 | def is_alive(self): |
| 756 | """ |
| 757 | Return True if the VM's monitor is responsive. |
| 758 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 759 | # Check if the process is running |
| 760 | if self.is_dead(): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 761 | return False |
| 762 | # Try sending a monitor command |
| 763 | (status, output) = self.send_monitor_cmd("help") |
| 764 | if status: |
| 765 | return False |
| 766 | return True |
| 767 | |
| 768 | |
| 769 | def is_dead(self): |
| 770 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 771 | Return True if the qemu process is dead. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 772 | """ |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 773 | return not self.process or not self.process.is_alive() |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 774 | |
| 775 | |
lmr | a419700 | 2009-08-13 05:00:51 +0000 | [diff] [blame] | 776 | def kill_tail_thread(self): |
| 777 | """ |
| 778 | Stop the tailing thread which reports the output of qemu. |
| 779 | """ |
| 780 | if self.process: |
| 781 | self.process.kill_tail_thread() |
| 782 | |
| 783 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 784 | def get_params(self): |
| 785 | """ |
| 786 | Return the VM's params dict. Most modified params take effect only |
| 787 | upon VM.create(). |
| 788 | """ |
| 789 | return self.params |
| 790 | |
| 791 | |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 792 | def get_address(self, index=0): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 793 | """ |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 794 | Return the address of a NIC of the guest, in host space. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 795 | |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 796 | If port redirection is used, return 'localhost' (the NIC has no IP |
| 797 | address of its own). Otherwise return the NIC's IP address. |
| 798 | |
| 799 | @param index: Index of the NIC whose address is requested. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 800 | """ |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 801 | nics = kvm_utils.get_sub_dict_names(self.params, "nics") |
| 802 | nic_name = nics[index] |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 803 | nic_params = kvm_utils.get_sub_dict(self.params, nic_name) |
| 804 | if nic_params.get("nic_mode") == "tap": |
| 805 | mac, ip = kvm_utils.get_mac_ip_pair_from_dict(nic_params) |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 806 | if not mac: |
| 807 | logging.debug("MAC address unavailable") |
| 808 | return None |
| 809 | if not ip or nic_params.get("always_use_tcpdump") == "yes": |
| 810 | # Get the IP address from the cache |
| 811 | ip = self.address_cache.get(mac) |
| 812 | if not ip: |
| 813 | logging.debug("Could not find IP address for MAC address: " |
| 814 | "%s" % mac) |
| 815 | return None |
| 816 | # Make sure the IP address is assigned to this guest |
| 817 | nic_dicts = [kvm_utils.get_sub_dict(self.params, nic) |
| 818 | for nic in nics] |
| 819 | macs = [kvm_utils.get_mac_ip_pair_from_dict(dict)[0] |
| 820 | for dict in nic_dicts] |
| 821 | if not kvm_utils.verify_ip_address_ownership(ip, macs): |
| 822 | logging.debug("Could not verify MAC-IP address mapping: " |
| 823 | "%s ---> %s" % (mac, ip)) |
| 824 | return None |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 825 | return ip |
| 826 | else: |
| 827 | return "localhost" |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 828 | |
| 829 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 830 | def get_port(self, port, nic_index=0): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 831 | """ |
| 832 | Return the port in host space corresponding to port in guest space. |
| 833 | |
| 834 | @param port: Port number in host space. |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 835 | @param nic_index: Index of the NIC. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 836 | @return: If port redirection is used, return the host port redirected |
| 837 | to guest port port. Otherwise return port. |
| 838 | """ |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 839 | nic_name = kvm_utils.get_sub_dict_names(self.params, "nics")[nic_index] |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 840 | nic_params = kvm_utils.get_sub_dict(self.params, nic_name) |
| 841 | if nic_params.get("nic_mode") == "tap": |
| 842 | return port |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 843 | else: |
lmr | f469634 | 2009-08-13 04:06:33 +0000 | [diff] [blame] | 844 | if not self.redirs.has_key(port): |
| 845 | logging.warn("Warning: guest port %s requested but not " |
| 846 | "redirected" % port) |
| 847 | return self.redirs.get(port) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 848 | |
| 849 | |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 850 | def get_pid(self): |
| 851 | """ |
lmr | 71fa4de | 2010-06-14 15:54:55 +0000 | [diff] [blame] | 852 | Return the VM's PID. If the VM is dead return None. |
| 853 | |
| 854 | @note: This works under the assumption that self.process.get_pid() |
| 855 | returns the PID of the parent shell process. |
| 856 | """ |
| 857 | try: |
| 858 | children = commands.getoutput("ps --ppid=%d -o pid=" % |
| 859 | self.process.get_pid()).split() |
| 860 | return int(children[0]) |
| 861 | except (TypeError, IndexError, ValueError): |
| 862 | return None |
| 863 | |
| 864 | |
| 865 | def get_shell_pid(self): |
| 866 | """ |
| 867 | Return the PID of the parent shell process. |
| 868 | |
| 869 | @note: This works under the assumption that self.process.get_pid() |
| 870 | returns the PID of the parent shell process. |
lmr | a496762 | 2009-07-23 01:36:32 +0000 | [diff] [blame] | 871 | """ |
| 872 | return self.process.get_pid() |
| 873 | |
| 874 | |
lmr | 0bee234 | 2010-02-24 00:01:37 +0000 | [diff] [blame] | 875 | def get_shared_meminfo(self): |
| 876 | """ |
| 877 | Returns the VM's shared memory information. |
| 878 | |
| 879 | @return: Shared memory used by VM (MB) |
| 880 | """ |
| 881 | if self.is_dead(): |
| 882 | logging.error("Could not get shared memory info from dead VM.") |
| 883 | return None |
| 884 | |
lmr | 983ecdf | 2010-06-14 15:57:12 +0000 | [diff] [blame] | 885 | filename = "/proc/%d/statm" % self.get_pid() |
| 886 | shm = int(open(filename).read().split()[2]) |
lmr | 0bee234 | 2010-02-24 00:01:37 +0000 | [diff] [blame] | 887 | # statm stores informations in pages, translate it to MB |
lmr | 983ecdf | 2010-06-14 15:57:12 +0000 | [diff] [blame] | 888 | return shm * 4.0 / 1024 |
lmr | 0bee234 | 2010-02-24 00:01:37 +0000 | [diff] [blame] | 889 | |
| 890 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 891 | def remote_login(self, nic_index=0, timeout=10): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 892 | """ |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 893 | Log into the guest via SSH/Telnet/Netcat. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 894 | If timeout expires while waiting for output from the guest (e.g. a |
| 895 | password prompt or a shell prompt) -- fail. |
| 896 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 897 | @param nic_index: The index of the NIC to connect to. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 898 | @param timeout: Time (seconds) before giving up logging into the |
| 899 | guest. |
| 900 | @return: kvm_spawn object on success and None on failure. |
| 901 | """ |
| 902 | username = self.params.get("username", "") |
| 903 | password = self.params.get("password", "") |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 904 | prompt = self.params.get("shell_prompt", "[\#\$]") |
lmr | 59f9e2d | 2009-10-05 18:47:16 +0000 | [diff] [blame] | 905 | linesep = eval("'%s'" % self.params.get("shell_linesep", r"\n")) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 906 | client = self.params.get("shell_client") |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 907 | address = self.get_address(nic_index) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 908 | port = self.get_port(int(self.params.get("shell_port"))) |
| 909 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 910 | if not address or not port: |
| 911 | logging.debug("IP address or port unavailable") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 912 | return None |
| 913 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 914 | if client == "ssh": |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 915 | session = kvm_utils.ssh(address, port, username, password, |
lmr | 59f9e2d | 2009-10-05 18:47:16 +0000 | [diff] [blame] | 916 | prompt, linesep, timeout) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 917 | elif client == "telnet": |
| 918 | session = kvm_utils.telnet(address, port, username, password, |
lmr | 59f9e2d | 2009-10-05 18:47:16 +0000 | [diff] [blame] | 919 | prompt, linesep, timeout) |
lmr | 9f6ebf1 | 2009-08-17 20:44:10 +0000 | [diff] [blame] | 920 | elif client == "nc": |
| 921 | session = kvm_utils.netcat(address, port, username, password, |
lmr | 59f9e2d | 2009-10-05 18:47:16 +0000 | [diff] [blame] | 922 | prompt, linesep, timeout) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 923 | |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 924 | if session: |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 925 | session.set_status_test_command(self.params.get("status_test_" |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 926 | "command", "")) |
| 927 | return session |
| 928 | |
| 929 | |
lmr | c196d49 | 2010-05-07 14:14:26 +0000 | [diff] [blame] | 930 | def copy_files_to(self, local_path, remote_path, nic_index=0, timeout=600): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 931 | """ |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 932 | Transfer files to the guest. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 933 | |
| 934 | @param local_path: Host path |
| 935 | @param remote_path: Guest path |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 936 | @param nic_index: The index of the NIC to connect to. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 937 | @param timeout: Time (seconds) before giving up on doing the remote |
| 938 | copy. |
| 939 | """ |
| 940 | username = self.params.get("username", "") |
| 941 | password = self.params.get("password", "") |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 942 | client = self.params.get("file_transfer_client") |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 943 | address = self.get_address(nic_index) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 944 | port = self.get_port(int(self.params.get("file_transfer_port"))) |
| 945 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 946 | if not address or not port: |
| 947 | logging.debug("IP address or port unavailable") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 948 | return None |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 949 | |
| 950 | if client == "scp": |
| 951 | return kvm_utils.scp_to_remote(address, port, username, password, |
| 952 | local_path, remote_path, timeout) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 953 | |
| 954 | |
lmr | c196d49 | 2010-05-07 14:14:26 +0000 | [diff] [blame] | 955 | def copy_files_from(self, remote_path, local_path, nic_index=0, timeout=600): |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 956 | """ |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 957 | Transfer files from the guest. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 958 | |
| 959 | @param local_path: Guest path |
| 960 | @param remote_path: Host path |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 961 | @param nic_index: The index of the NIC to connect to. |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 962 | @param timeout: Time (seconds) before giving up on doing the remote |
| 963 | copy. |
| 964 | """ |
| 965 | username = self.params.get("username", "") |
| 966 | password = self.params.get("password", "") |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 967 | client = self.params.get("file_transfer_client") |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 968 | address = self.get_address(nic_index) |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 969 | port = self.get_port(int(self.params.get("file_transfer_port"))) |
| 970 | |
lmr | ee90dd9 | 2009-08-13 04:13:39 +0000 | [diff] [blame] | 971 | if not address or not port: |
| 972 | logging.debug("IP address or port unavailable") |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 973 | return None |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 974 | |
lmr | 912c74b | 2009-08-17 20:43:27 +0000 | [diff] [blame] | 975 | if client == "scp": |
| 976 | return kvm_utils.scp_from_remote(address, port, username, password, |
| 977 | remote_path, local_path, timeout) |
lmr | 6f669ce | 2009-05-31 19:02:42 +0000 | [diff] [blame] | 978 | |
| 979 | |
| 980 | def send_key(self, keystr): |
| 981 | """ |
| 982 | Send a key event to the VM. |
| 983 | |
| 984 | @param: keystr: A key event string (e.g. "ctrl-alt-delete") |
| 985 | """ |
| 986 | # For compatibility with versions of QEMU that do not recognize all |
| 987 | # key names: replace keyname with the hex value from the dict, which |
| 988 | # QEMU will definitely accept |
| 989 | dict = { "comma": "0x33", |
| 990 | "dot": "0x34", |
| 991 | "slash": "0x35" } |
| 992 | for key in dict.keys(): |
| 993 | keystr = keystr.replace(key, dict[key]) |
| 994 | self.send_monitor_cmd("sendkey %s 1" % keystr) |
| 995 | time.sleep(0.2) |
| 996 | |
| 997 | |
| 998 | def send_string(self, str): |
| 999 | """ |
| 1000 | Send a string to the VM. |
| 1001 | |
| 1002 | @param str: String, that must consist of alphanumeric characters only. |
| 1003 | Capital letters are allowed. |
| 1004 | """ |
| 1005 | for char in str: |
| 1006 | if char.isupper(): |
| 1007 | self.send_key("shift-%s" % char.lower()) |
| 1008 | else: |
| 1009 | self.send_key(char) |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 1010 | |
mbligh | 1ef218d | 2009-08-03 16:57:56 +0000 | [diff] [blame] | 1011 | |
lmr | a253322 | 2009-07-20 12:43:46 +0000 | [diff] [blame] | 1012 | def get_uuid(self): |
| 1013 | """ |
| 1014 | Catch UUID of the VM. |
| 1015 | |
| 1016 | @return: None,if not specified in config file |
| 1017 | """ |
| 1018 | if self.params.get("uuid") == "random": |
| 1019 | return self.uuid |
| 1020 | else: |
| 1021 | return self.params.get("uuid", None) |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1022 | |
| 1023 | |
| 1024 | def get_cpu_count(self): |
| 1025 | """ |
| 1026 | Get the cpu count of the VM. |
| 1027 | """ |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1028 | session = self.remote_login() |
| 1029 | if not session: |
| 1030 | return None |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1031 | try: |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1032 | cmd = self.params.get("cpu_chk_cmd") |
| 1033 | s, count = session.get_command_status_output(cmd) |
| 1034 | if s == 0: |
| 1035 | return int(count) |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1036 | return None |
| 1037 | finally: |
| 1038 | session.close() |
| 1039 | |
| 1040 | |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1041 | def get_memory_size(self, cmd=None): |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1042 | """ |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1043 | Get bootup memory size of the VM. |
| 1044 | |
| 1045 | @param check_cmd: Command used to check memory. If not provided, |
| 1046 | self.params.get("mem_chk_cmd") will be used. |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1047 | """ |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1048 | session = self.remote_login() |
| 1049 | if not session: |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1050 | return None |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1051 | try: |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1052 | if not cmd: |
| 1053 | cmd = self.params.get("mem_chk_cmd") |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1054 | s, mem_str = session.get_command_status_output(cmd) |
| 1055 | if s != 0: |
| 1056 | return None |
lmr | 6d69f4d | 2010-02-12 11:35:55 +0000 | [diff] [blame] | 1057 | mem = re.findall("([0-9]+)", mem_str) |
lmr | 1342655 | 2010-01-17 15:38:41 +0000 | [diff] [blame] | 1058 | mem_size = 0 |
| 1059 | for m in mem: |
| 1060 | mem_size += int(m) |
| 1061 | if "GB" in mem_str: |
| 1062 | mem_size *= 1024 |
| 1063 | elif "MB" in mem_str: |
| 1064 | pass |
| 1065 | else: |
| 1066 | mem_size /= 1024 |
| 1067 | return int(mem_size) |
lmr | dd2ff92 | 2009-12-01 23:39:12 +0000 | [diff] [blame] | 1068 | finally: |
| 1069 | session.close() |
lmr | 28426c8 | 2010-04-16 06:02:58 +0000 | [diff] [blame] | 1070 | |
| 1071 | |
| 1072 | def get_current_memory_size(self): |
| 1073 | """ |
| 1074 | Get current memory size of the VM, rather than bootup memory. |
| 1075 | """ |
| 1076 | cmd = self.params.get("mem_chk_cur_cmd") |
| 1077 | return self.get_memory_size(cmd) |