Revert "Merge remote branch 'cros/upstream' into autotest-rebase"

client/tests/kvm/kvm_vm.py

 #!/usr/bin/python
 """
 Utility classes and functions to handle Virtual Machine creation using qemu.
 
 @copyright: 2008-2009 Red Hat Inc.
 """
 
 import time, socket, os, logging, fcntl, re, commands, shelve, glob
 import kvm_utils, kvm_subprocess, kvm_monitor, rss_file_transfer
 from autotest_lib.client.common_lib import error
 from autotest_lib.client.bin import utils
 
 
 def get_image_filename(params, root_dir):
     """
     Generate an image path from params and root_dir.
 
     @param params: Dictionary containing the test parameters.
     @param root_dir: Base directory for relative filenames.
 
     @note: params should contain:
            image_name -- the name of the image file, without extension
            image_format -- the format of the image (qcow2, raw etc)
     """
     image_name = params.get("image_name", "image")
     image_format = params.get("image_format", "qcow2")
-    if params.get("image_raw_device") == "yes":
-        return image_name
     image_filename = "%s.%s" % (image_name, image_format)
     image_filename = kvm_utils.get_path(root_dir, image_filename)
     return image_filename
 
 
 def create_image(params, root_dir):
     """
     Create an image using qemu_image.
 
     @param params: Dictionary containing the test parameters.
@@ skipping 51 matching lines @@
         os.unlink(image_filename)
     else:
         logging.debug("Image file %s not found")
 
 
 class VM:
     """
     This class handles all basic VM operations.
     """
 
-    def __init__(self, name, params, root_dir, address_cache, state=None):
+    def __init__(self, name, params, root_dir, address_cache):
         """
         Initialize the object and set a few attributes.
 
         @param name: The name of the object
         @param params: A dict containing VM params
                 (see method make_qemu_command for a full description)
         @param root_dir: Base directory for relative filenames
         @param address_cache: A dict that maps MAC addresses to IP addresses
-        @param state: If provided, use this as self.__dict__
         """
-        if state:
-            self.__dict__ = state
-        else:
-            self.process = None
-            self.serial_console = None
-            self.redirs = {}
-            self.vnc_port = 5900
-            self.monitors = []
-            self.pci_assignable = None
-            self.netdev_id = []
-            self.uuid = None
-
-            # Find a unique identifier for this VM
-            while True:
-                self.instance = (time.strftime("%Y%m%d-%H%M%S-") +
-                                 kvm_utils.generate_random_string(4))
-                if not glob.glob("/tmp/*%s" % self.instance):
-                    break
+        self.process = None
+        self.serial_console = None
+        self.redirs = {}
+        self.vnc_port = 5900
+        self.monitors = []
+        self.pci_assignable = None
+        self.netdev_id = []
+        self.uuid = None
 
         self.name = name
         self.params = params
         self.root_dir = root_dir
         self.address_cache = address_cache
 
+        # Find a unique identifier for this VM
+        while True:
+            self.instance = (time.strftime("%Y%m%d-%H%M%S-") +
+                             kvm_utils.generate_random_string(4))
+            if not glob.glob("/tmp/*%s" % self.instance):
+                break
 
-    def clone(self, name=None, params=None, root_dir=None, address_cache=None,
-              copy_state=False):
+
+    def clone(self, name=None, params=None, root_dir=None, address_cache=None):
         """
         Return a clone of the VM object with optionally modified parameters.
         The clone is initially not alive and needs to be started using create().
         Any parameters not passed to this function are copied from the source
         VM.
 
         @param name: Optional new VM name
         @param params: Optional new VM creation parameters
         @param root_dir: Optional new base directory for relative filenames
         @param address_cache: A dict that maps MAC addresses to IP addresses
-        @param copy_state: If True, copy the original VM's state to the clone.
-                Mainly useful for make_qemu_command().
         """
         if name is None:
             name = self.name
         if params is None:
             params = self.params.copy()
         if root_dir is None:
             root_dir = self.root_dir
         if address_cache is None:
             address_cache = self.address_cache
-        if copy_state:
-            state = self.__dict__.copy()
-        else:
-            state = None
-        return VM(name, params, root_dir, address_cache, state)
+        return VM(name, params, root_dir, address_cache)
 
 
     def make_qemu_command(self, name=None, params=None, root_dir=None):
         """
         Generate a qemu command line. All parameters are optional. If a
         parameter is not supplied, the corresponding value stored in the
         class attributes is used.
 
         @param name: The name of the object
         @param params: A dict containing VM params
@@ skipping 68 matching lines @@
             if format: cmd += ",if=%s" % format
             if cache: cmd += ",cache=%s" % cache
             if werror: cmd += ",werror=%s" % werror
             if serial: cmd += ",serial='%s'" % serial
             if snapshot: cmd += ",snapshot=on"
             if boot: cmd += ",boot=on"
             return cmd
 
         def add_nic(help, vlan, model=None, mac=None, netdev_id=None,
                     nic_extra_params=None):
-            if has_option(help, "netdev"):
-                netdev_vlan_str = ",netdev=%s" % netdev_id
-            else:
-                netdev_vlan_str = ",vlan=%d" % vlan
             if has_option(help, "device"):
+                if model == "virtio":
+                    model="virtio-net-pci"
                 if not model:
-                    model = "rtl8139"
-                elif model == "virtio":
-                    model = "virtio-net-pci"
-                cmd = " -device %s" % model + netdev_vlan_str
+                    model= "rtl8139"
+                cmd = " -device %s" % model
                 if mac:
-                    cmd += ",mac='%s'" % mac
+                    cmd += ",mac=%s" % mac
+                if has_option(help, "netdev"):
+                    cmd += ",netdev=%s" % netdev_id
+                else:
+                    cmd += "vlan=%d,"  % vlan
                 if nic_extra_params:
                     cmd += ",%s" % nic_extra_params
             else:
-                cmd = " -net nic" + netdev_vlan_str
+                if has_option(help, "netdev"):
+                    cmd = " -net nic,netdev=%s" % netdev_id
+                else:
+                    cmd = " -net nic,vlan=%d" % vlan
                 if model:
                     cmd += ",model=%s" % model
                 if mac:
                     cmd += ",macaddr='%s'" % mac
             return cmd
 
         def add_net(help, vlan, mode, ifname=None, script=None,
                     downscript=None, tftp=None, bootfile=None, hostfwd=[],
-                    netdev_id=None, netdev_extra_params=None):
+                    netdev_id=None, vhost=False):
             if has_option(help, "netdev"):
                 cmd = " -netdev %s,id=%s" % (mode, netdev_id)
-                if netdev_extra_params:
-                    cmd += ",%s" % netdev_extra_params
+                if vhost:
+                    cmd +=",vhost=on"
             else:
                 cmd = " -net %s,vlan=%d" % (mode, vlan)
             if mode == "tap":
                 if ifname: cmd += ",ifname='%s'" % ifname
                 if script: cmd += ",script='%s'" % script
                 cmd += ",downscript='%s'" % (downscript or "no")
             elif mode == "user":
                 if tftp and "[,tftp=" in help:
                     cmd += ",tftp='%s'" % tftp
                 if bootfile and "[,bootfile=" in help:
@@ skipping 63 matching lines @@
                 return " -no-hpet"
             else:
                 return ""
 
         # End of command line option wrappers
 
         if name is None: name = self.name
         if params is None: params = self.params
         if root_dir is None: root_dir = self.root_dir
 
-        # Clone this VM using the new params
-        vm = self.clone(name, params, root_dir, copy_state=True)
-
         qemu_binary = kvm_utils.get_path(root_dir, params.get("qemu_binary",
                                                               "qemu"))
         # Get the output of 'qemu -help' (log a message in case this call never
         # returns or causes some other kind of trouble)
         logging.debug("Getting output of 'qemu -help'")
         help = commands.getoutput("%s -help" % qemu_binary)
 
         # Start constructing the qemu command
         qemu_cmd = ""
         # Set the X11 display parameter if requested
         if params.get("x11_display"):
             qemu_cmd += "DISPLAY=%s " % params.get("x11_display")
         # Add the qemu binary
         qemu_cmd += qemu_binary
         # Add the VM's name
         qemu_cmd += add_name(help, name)
         # Add monitors
-        for monitor_name in params.objects("monitors"):
-            monitor_params = params.object_params(monitor_name)
-            monitor_filename = vm.get_monitor_filename(monitor_name)
+        for monitor_name in kvm_utils.get_sub_dict_names(params, "monitors"):
+            monitor_params = kvm_utils.get_sub_dict(params, monitor_name)
+            monitor_filename = self.get_monitor_filename(monitor_name)
             if monitor_params.get("monitor_type") == "qmp":
                 qemu_cmd += add_qmp_monitor(help, monitor_filename)
             else:
                 qemu_cmd += add_human_monitor(help, monitor_filename)
 
         # Add serial console redirection
-        qemu_cmd += add_serial(help, vm.get_serial_console_filename())
+        qemu_cmd += add_serial(help, self.get_serial_console_filename())
 
-        for image_name in params.objects("images"):
-            image_params = params.object_params(image_name)
+        for image_name in kvm_utils.get_sub_dict_names(params, "images"):
+            image_params = kvm_utils.get_sub_dict(params, image_name)
             if image_params.get("boot_drive") == "no":
                 continue
             qemu_cmd += add_drive(help,
                                   get_image_filename(image_params, root_dir),
                                   image_params.get("drive_index"),
                                   image_params.get("drive_format"),
                                   image_params.get("drive_cache"),
                                   image_params.get("drive_werror"),
                                   image_params.get("drive_serial"),
                                   image_params.get("image_snapshot") == "yes",
                                   image_params.get("image_boot") == "yes")
 
         redirs = []
-        for redir_name in params.objects("redirs"):
-            redir_params = params.object_params(redir_name)
+        for redir_name in kvm_utils.get_sub_dict_names(params, "redirs"):
+            redir_params = kvm_utils.get_sub_dict(params, redir_name)
             guest_port = int(redir_params.get("guest_port"))
-            host_port = vm.redirs.get(guest_port)
+            host_port = self.redirs.get(guest_port)
             redirs += [(host_port, guest_port)]
 
         vlan = 0
-        for nic_name in params.objects("nics"):
-            nic_params = params.object_params(nic_name)
-            try:
-                netdev_id = vm.netdev_id[vlan]
-            except IndexError:
-                netdev_id = None
+        for nic_name in kvm_utils.get_sub_dict_names(params, "nics"):
+            nic_params = kvm_utils.get_sub_dict(params, nic_name)
             # Handle the '-net nic' part
-            mac = vm.get_mac_address(vlan)
+            mac = self.get_mac_address(vlan)
             qemu_cmd += add_nic(help, vlan, nic_params.get("nic_model"), mac,
-                                netdev_id, nic_params.get("nic_extra_params"))
+                                self.netdev_id[vlan],
+                                nic_params.get("nic_extra_params"))
             # Handle the '-net tap' or '-net user' part
             script = nic_params.get("nic_script")
             downscript = nic_params.get("nic_downscript")
             tftp = nic_params.get("tftp")
             if script:
                 script = kvm_utils.get_path(root_dir, script)
             if downscript:
                 downscript = kvm_utils.get_path(root_dir, downscript)
             if tftp:
                 tftp = kvm_utils.get_path(root_dir, tftp)
             qemu_cmd += add_net(help, vlan, nic_params.get("nic_mode", "user"),
-                                vm.get_ifname(vlan),
+                                self.get_ifname(vlan),
                                 script, downscript, tftp,
-                                nic_params.get("bootp"), redirs, netdev_id,
-                                nic_params.get("netdev_extra_params"))
+                                nic_params.get("bootp"), redirs,
+                                self.netdev_id[vlan],
+                                nic_params.get("vhost")=="yes")
             # Proceed to next NIC
             vlan += 1
 
         mem = params.get("mem")
         if mem:
             qemu_cmd += add_mem(help, mem)
 
         smp = params.get("smp")
         if smp:
             qemu_cmd += add_smp(help, smp)
 
-        for cdrom in params.objects("cdroms"):
-            cdrom_params = params.object_params(cdrom)
+        cdroms = kvm_utils.get_sub_dict_names(params, "cdroms")
+        for cdrom in cdroms:
+            cdrom_params = kvm_utils.get_sub_dict(params, cdrom)
             iso = cdrom_params.get("cdrom")
             if iso:
                 qemu_cmd += add_cdrom(help, kvm_utils.get_path(root_dir, iso),
                                       cdrom_params.get("drive_index"))
 
         # We may want to add {floppy_otps} parameter for -fda
         # {fat:floppy:}/path/. However vvfat is not usually recommended.
         floppy = params.get("floppy")
         if floppy:
             floppy = kvm_utils.get_path(root_dir, floppy)
@@ skipping 19 matching lines @@
 
         initrd = params.get("initrd")
         if initrd:
             initrd = kvm_utils.get_path(root_dir, initrd)
             qemu_cmd += add_initrd(help, initrd)
 
         for host_port, guest_port in redirs:
             qemu_cmd += add_tcp_redir(help, host_port, guest_port)
 
         if params.get("display") == "vnc":
-            qemu_cmd += add_vnc(help, vm.vnc_port)
+            qemu_cmd += add_vnc(help, self.vnc_port)
         elif params.get("display") == "sdl":
             qemu_cmd += add_sdl(help)
         elif params.get("display") == "nographic":
             qemu_cmd += add_nographic(help)
 
         if params.get("uuid") == "random":
-            qemu_cmd += add_uuid(help, vm.uuid)
+            qemu_cmd += add_uuid(help, self.uuid)
         elif params.get("uuid"):
             qemu_cmd += add_uuid(help, params.get("uuid"))
 
         if params.get("testdev") == "yes":
-            qemu_cmd += add_testdev(help, vm.get_testlog_filename())
+            qemu_cmd += add_testdev(help, self.get_testlog_filename())
 
         if params.get("disable_hpet") == "yes":
             qemu_cmd += add_no_hpet(help)
 
         # If the PCI assignment step went OK, add each one of the PCI assigned
         # devices to the qemu command line.
-        if vm.pci_assignable:
-            for pci_id in vm.pa_pci_ids:
+        if self.pci_assignable:
+            for pci_id in self.pa_pci_ids:
                 qemu_cmd += add_pcidevice(help, pci_id)
 
         extra_params = params.get("extra_params")
         if extra_params:
             qemu_cmd += " %s" % extra_params
 
         return qemu_cmd
 
 
     def create(self, name=None, params=None, root_dir=None, timeout=5.0,
-               migration_mode=None, mac_source=None):
+               migration_mode=None, migration_exec_cmd=None, mac_source=None):
         """
         Start the VM by running a qemu command.
         All parameters are optional. If name, params or root_dir are not
         supplied, the respective values stored as class attributes are used.
 
         @param name: The name of the object
         @param params: A dict containing VM params
         @param root_dir: Base directory for relative filenames
         @param migration_mode: If supplied, start VM for incoming migration
                 using this protocol (either 'tcp', 'unix' or 'exec')
         @param migration_exec_cmd: Command to embed in '-incoming "exec: ..."'
                 (e.g. 'gzip -c -d filename') if migration_mode is 'exec'
         @param mac_source: A VM object from which to copy MAC addresses. If not
                 specified, new addresses will be generated.
         """
         self.destroy()
 
         if name is not None:
             self.name = name
         if params is not None:
             self.params = params
         if root_dir is not None:
             self.root_dir = root_dir
         name = self.name
         params = self.params
         root_dir = self.root_dir
 
-        # Verify the md5sum of the ISO images
-        for cdrom in params.objects("cdroms"):
-            cdrom_params = params.object_params(cdrom)
-            iso = cdrom_params.get("cdrom")
-            if iso:
-                iso = kvm_utils.get_path(root_dir, iso)
-                if not os.path.exists(iso):
-                    logging.error("ISO file not found: %s" % iso)
+        # Verify the md5sum of the ISO image
+        iso = params.get("cdrom")
+        if iso:
+            iso = kvm_utils.get_path(root_dir, iso)
+            if not os.path.exists(iso):
+                logging.error("ISO file not found: %s" % iso)
+                return False
+            compare = False
+            if params.get("md5sum_1m"):
+                logging.debug("Comparing expected MD5 sum with MD5 sum of "
+                              "first MB of ISO file...")
+                actual_hash = utils.hash_file(iso, 1048576, method="md5")
+                expected_hash = params.get("md5sum_1m")
+                compare = True
+            elif params.get("md5sum"):
+                logging.debug("Comparing expected MD5 sum with MD5 sum of ISO "
+                              "file...")
+                actual_hash = utils.hash_file(iso, method="md5")
+                expected_hash = params.get("md5sum")
+                compare = True
+            elif params.get("sha1sum"):
+                logging.debug("Comparing expected SHA1 sum with SHA1 sum of "
+                              "ISO file...")
+                actual_hash = utils.hash_file(iso, method="sha1")
+                expected_hash = params.get("sha1sum")
+                compare = True
+            if compare:
+                if actual_hash == expected_hash:
+                    logging.debug("Hashes match")
+                else:
+                    logging.error("Actual hash differs from expected one")
                     return False
-                compare = False
-                if cdrom_params.get("md5sum_1m"):
-                    logging.debug("Comparing expected MD5 sum with MD5 sum of "
-                                  "first MB of ISO file...")
-                    actual_hash = utils.hash_file(iso, 1048576, method="md5")
-                    expected_hash = cdrom_params.get("md5sum_1m")
-                    compare = True
-                elif cdrom_params.get("md5sum"):
-                    logging.debug("Comparing expected MD5 sum with MD5 sum of "
-                                  "ISO file...")
-                    actual_hash = utils.hash_file(iso, method="md5")
-                    expected_hash = cdrom_params.get("md5sum")
-                    compare = True
-                elif cdrom_params.get("sha1sum"):
-                    logging.debug("Comparing expected SHA1 sum with SHA1 sum "
-                                  "of ISO file...")
-                    actual_hash = utils.hash_file(iso, method="sha1")
-                    expected_hash = cdrom_params.get("sha1sum")
-                    compare = True
-                if compare:
-                    if actual_hash == expected_hash:
-                        logging.debug("Hashes match")
-                    else:
-                        logging.error("Actual hash differs from expected one")
-                        return False
 
         # Make sure the following code is not executed by more than one thread
         # at the same time
         lockfile = open("/tmp/kvm-autotest-vm-create.lock", "w+")
         fcntl.lockf(lockfile, fcntl.LOCK_EX)
 
         try:
             # Handle port redirections
-            redir_names = params.objects("redirs")
+            redir_names = kvm_utils.get_sub_dict_names(params, "redirs")
             host_ports = kvm_utils.find_free_ports(5000, 6000, len(redir_names))
             self.redirs = {}
             for i in range(len(redir_names)):
-                redir_params = params.object_params(redir_names[i])
+                redir_params = kvm_utils.get_sub_dict(params, redir_names[i])
                 guest_port = int(redir_params.get("guest_port"))
                 self.redirs[guest_port] = host_ports[i]
 
-            # Generate netdev IDs for all NICs
-            self.netdev_id = []
-            for nic in params.objects("nics"):
+            for nic in kvm_utils.get_sub_dict_names(params, "nics"):
                 self.netdev_id.append(kvm_utils.generate_random_id())
 
             # Find available VNC port, if needed
             if params.get("display") == "vnc":
                 self.vnc_port = kvm_utils.find_free_port(5900, 6100)
 
             # Find random UUID if specified 'uuid = random' in config file
             if params.get("uuid") == "random":
                 f = open("/proc/sys/kernel/random/uuid")
                 self.uuid = f.read().strip()
                 f.close()
 
             # Generate or copy MAC addresses for all NICs
-            num_nics = len(params.objects("nics"))
+            num_nics = len(kvm_utils.get_sub_dict_names(params, "nics"))
             for vlan in range(num_nics):
-                nic_name = params.objects("nics")[vlan]
-                nic_params = params.object_params(nic_name)
-                if nic_params.get("nic_mac", None):
-                    mac = nic_params.get("nic_mac")
+                mac = mac_source and mac_source.get_mac_address(vlan)
+                if mac:
                     kvm_utils.set_mac_address(self.instance, vlan, mac)
                 else:
-                    mac = mac_source and mac_source.get_mac_address(vlan)
-                    if mac:
-                        kvm_utils.set_mac_address(self.instance, vlan, mac)
-                    else:
-                        kvm_utils.generate_mac_address(self.instance, vlan)
+                    kvm_utils.generate_mac_address(self.instance, vlan)
 
             # Assign a PCI assignable device
             self.pci_assignable = None
             pa_type = params.get("pci_assignable")
             if pa_type in ["vf", "pf", "mixed"]:
                 pa_devices_requested = params.get("devices_requested")
 
                 # Virtual Functions (VF) assignable devices
                 if pa_type == "vf":
                     self.pci_assignable = kvm_utils.PciAssignable(
@@ skipping 35 matching lines @@
             qemu_command = self.make_qemu_command()
 
             # Add migration parameters if required
             if migration_mode == "tcp":
                 self.migration_port = kvm_utils.find_free_port(5200, 6000)
                 qemu_command += " -incoming tcp:0:%d" % self.migration_port
             elif migration_mode == "unix":
                 self.migration_file = "/tmp/migration-unix-%s" % self.instance
                 qemu_command += " -incoming unix:%s" % self.migration_file
             elif migration_mode == "exec":
-                self.migration_port = kvm_utils.find_free_port(5200, 6000)
-                qemu_command += (' -incoming "exec:nc -l %s"' %
-                                 self.migration_port)
+                qemu_command += ' -incoming "exec:%s"' % migration_exec_cmd
 
             logging.debug("Running qemu command:\n%s", qemu_command)
             self.process = kvm_subprocess.run_bg(qemu_command, None,
                                                  logging.debug, "(qemu) ")
 
             # Make sure the process was started successfully
             if not self.process.is_alive():
                 logging.error("VM could not be created; "
                               "qemu command failed:\n%s" % qemu_command)
                 logging.error("Status: %s" % self.process.get_status())
                 logging.error("Output:" + kvm_utils.format_str_for_message(
                     self.process.get_output()))
                 self.destroy()
                 return False
 
             # Establish monitor connections
             self.monitors = []
-            for monitor_name in params.objects("monitors"):
-                monitor_params = params.object_params(monitor_name)
+            for monitor_name in kvm_utils.get_sub_dict_names(params,
+                                                             "monitors"):
+                monitor_params = kvm_utils.get_sub_dict(params, monitor_name)
                 # Wait for monitor connection to succeed
                 end_time = time.time() + timeout
                 while time.time() < end_time:
                     try:
                         if monitor_params.get("monitor_type") == "qmp":
                             # Add a QMP monitor
                             monitor = kvm_monitor.QMPMonitor(
                                 monitor_name,
                                 self.get_monitor_filename(monitor_name))
                         else:
@@ skipping 32 matching lines @@
                               "qemu command:\n%s" % qemu_command)
                 logging.error("Output:" + kvm_utils.format_str_for_message(
                               self.process.get_output()))
                 self.destroy()
                 return False
 
             logging.debug("VM appears to be alive with PID %s", self.get_pid())
 
             # Establish a session with the serial console -- requires a version
             # of netcat that supports -U
-            self.serial_console = kvm_subprocess.ShellSession(
+            self.serial_console = kvm_subprocess.kvm_shell_session(
                 "nc -U %s" % self.get_serial_console_filename(),
                 auto_close=False,
                 output_func=kvm_utils.log_line,
                 output_params=("serial-%s.log" % name,))
 
             return True
 
         finally:
             fcntl.lockf(lockfile, fcntl.LOCK_UN)
             lockfile.close()
@@ skipping 72 matching lines @@
                       self.get_monitor_filenames()):
                 try:
                     os.unlink(f)
                 except OSError:
                     pass
             if hasattr(self, "migration_file"):
                 try:
                     os.unlink(self.migration_file)
                 except OSError:
                     pass
-            num_nics = len(self.params.objects("nics"))
+            num_nics = len(kvm_utils.get_sub_dict_names(self.params, "nics"))
             for vlan in range(num_nics):
                 self.free_mac_address(vlan)
 
 
     @property
     def monitor(self):
         """
         Return the main monitor object, selected by the parameter main_monitor.
         If main_monitor isn't defined, return the first monitor.
         If no monitors exist, or if main_monitor refers to a nonexistent
@@ skipping 38 matching lines @@
         """
         return "/tmp/monitor-%s-%s" % (monitor_name, self.instance)
 
 
     def get_monitor_filenames(self):
         """
         Return a list of all monitor filenames (as specified in the VM's
         params).
         """
         return [self.get_monitor_filename(m) for m in
-                self.params.objects("monitors")]
+                kvm_utils.get_sub_dict_names(self.params, "monitors")]
 
 
     def get_serial_console_filename(self):
         """
         Return the serial console filename.
         """
         return "/tmp/serial-%s" % self.instance
 
 
     def get_testlog_filename(self):
         """
         Return the testlog filename.
         """
         return "/tmp/testlog-%s" % self.instance
 
 
     def get_address(self, index=0):
         """
         Return the address of a NIC of the guest, in host space.
 
         If port redirection is used, return 'localhost' (the NIC has no IP
         address of its own).  Otherwise return the NIC's IP address.
 
         @param index: Index of the NIC whose address is requested.
         """
-        nics = self.params.objects("nics")
+        nics = kvm_utils.get_sub_dict_names(self.params, "nics")
         nic_name = nics[index]
-        nic_params = self.params.object_params(nic_name)
+        nic_params = kvm_utils.get_sub_dict(self.params, nic_name)
         if nic_params.get("nic_mode") == "tap":
             mac = self.get_mac_address(index)
             if not mac:
                 logging.debug("MAC address unavailable")
                 return None
             mac = mac.lower()
             # Get the IP address from the cache
             ip = self.address_cache.get(mac)
             if not ip:
                 logging.debug("Could not find IP address for MAC address: %s" %
@@ skipping 12 matching lines @@
 
     def get_port(self, port, nic_index=0):
         """
         Return the port in host space corresponding to port in guest space.
 
         @param port: Port number in host space.
         @param nic_index: Index of the NIC.
         @return: If port redirection is used, return the host port redirected
                 to guest port port. Otherwise return port.
         """
-        nic_name = self.params.objects("nics")[nic_index]
-        nic_params = self.params.object_params(nic_name)
+        nic_name = kvm_utils.get_sub_dict_names(self.params, "nics")[nic_index]
+        nic_params = kvm_utils.get_sub_dict(self.params, nic_name)
         if nic_params.get("nic_mode") == "tap":
             return port
         else:
             if not self.redirs.has_key(port):
                 logging.warn("Warning: guest port %s requested but not "
                              "redirected" % port)
             return self.redirs.get(port)
 
 
     def get_ifname(self, nic_index=0):
         """
         Return the ifname of a tap device associated with a NIC.
 
         @param nic_index: Index of the NIC
         """
-        nics = self.params.objects("nics")
+        nics = kvm_utils.get_sub_dict_names(self.params, "nics")
         nic_name = nics[nic_index]
-        nic_params = self.params.object_params(nic_name)
+        nic_params = kvm_utils.get_sub_dict(self.params, nic_name)
         if nic_params.get("nic_ifname"):
             return nic_params.get("nic_ifname")
         else:
             return "t%d-%s" % (nic_index, self.instance[-11:])
 
 
     def get_mac_address(self, nic_index=0):
         """
         Return the MAC address of a NIC.
 
@@ skipping 54 matching lines @@
 
     def remote_login(self, nic_index=0, timeout=10):
         """
         Log into the guest via SSH/Telnet/Netcat.
         If timeout expires while waiting for output from the guest (e.g. a
         password prompt or a shell prompt) -- fail.
 
         @param nic_index: The index of the NIC to connect to.
         @param timeout: Time (seconds) before giving up logging into the
                 guest.
-        @return: ShellSession object on success and None on failure.
+        @return: kvm_spawn object on success and None on failure.
         """
         username = self.params.get("username", "")
         password = self.params.get("password", "")
         prompt = self.params.get("shell_prompt", "[\#\$]")
         linesep = eval("'%s'" % self.params.get("shell_linesep", r"\n"))
         client = self.params.get("shell_client")
         address = self.get_address(nic_index)
         port = self.get_port(int(self.params.get("shell_port")))
         log_filename = ("session-%s-%s.log" %
                         (self.name, kvm_utils.generate_random_string(4)))
 
         if not address or not port:
             logging.debug("IP address or port unavailable")
             return None
 
         session = kvm_utils.remote_login(client, address, port, username,
                                          password, prompt, linesep,
                                          log_filename, timeout)
 
         if session:
             session.set_status_test_command(self.params.get("status_test_"
                                                             "command", ""))
         return session
 
 
     def copy_files_to(self, local_path, remote_path, nic_index=0, timeout=600):
         """
-        Transfer files to the remote host(guest).
+        Transfer files to the guest.
 
         @param local_path: Host path
         @param remote_path: Guest path
         @param nic_index: The index of the NIC to connect to.
         @param timeout: Time (seconds) before giving up on doing the remote
                 copy.
         """
         username = self.params.get("username", "")
         password = self.params.get("password", "")
         client = self.params.get("file_transfer_client")
         address = self.get_address(nic_index)
         port = self.get_port(int(self.params.get("file_transfer_port")))
 
-        log_filename = ("transfer-%s-to-%s-%s.log" %
-                        (self.name, address,
-                        kvm_utils.generate_random_string(4)))
-        return kvm_utils.copy_files_to(address, client, username, password,
-                                       port, local_path, remote_path,
-                                       log_filename, timeout)
+        if not address or not port:
+            logging.debug("IP address or port unavailable")
+            return None
+
+        if client == "scp":
+            log_filename = ("scp-%s-%s.log" %
+                            (self.name, kvm_utils.generate_random_string(4)))
+            return kvm_utils.scp_to_remote(address, port, username, password,
+                                           local_path, remote_path,
+                                           log_filename, timeout)
+        elif client == "rss":
+            c = rss_file_transfer.FileUploadClient(address, port)
+            c.upload(local_path, remote_path, timeout)
+            c.close()
+            return True
 
 
     def copy_files_from(self, remote_path, local_path, nic_index=0, timeout=600):
         """
         Transfer files from the guest.
 
         @param local_path: Guest path
         @param remote_path: Host path
         @param nic_index: The index of the NIC to connect to.
         @param timeout: Time (seconds) before giving up on doing the remote
                 copy.
         """
         username = self.params.get("username", "")
         password = self.params.get("password", "")
         client = self.params.get("file_transfer_client")
         address = self.get_address(nic_index)
         port = self.get_port(int(self.params.get("file_transfer_port")))
 
-        log_filename = ("transfer-%s-from-%s-%s.log" %
-                        (self.name, address,
-                        kvm_utils.generate_random_string(4)))
-        return kvm_utils.copy_files_from(address, client, username, password,
-                        port, local_path, remote_path, log_filename, timeout)
+        if not address or not port:
+            logging.debug("IP address or port unavailable")
+            return None
+
+        if client == "scp":
+            log_filename = ("scp-%s-%s.log" %
+                            (self.name, kvm_utils.generate_random_string(4)))
+            return kvm_utils.scp_from_remote(address, port, username, password,
+                                             remote_path, local_path,
+                                             log_filename, timeout)
+        elif client == "rss":
+            c = rss_file_transfer.FileDownloadClient(address, port)
+            c.download(remote_path, local_path, timeout)
+            c.close()
+            return True
 
 
     def serial_login(self, timeout=10):
         """
         Log into the guest via the serial console.
         If timeout expires while waiting for output from the guest (e.g. a
         password prompt or a shell prompt) -- fail.
 
         @param timeout: Time (seconds) before giving up logging into the guest.
-        @return: ShellSession object on success and None on failure.
+        @return: kvm_spawn object on success and None on failure.
         """
         username = self.params.get("username", "")
         password = self.params.get("password", "")
         prompt = self.params.get("shell_prompt", "[\#\$]")
         linesep = eval("'%s'" % self.params.get("shell_linesep", r"\n"))
         status_test_command = self.params.get("status_test_command", "")
 
         if self.serial_console:
             self.serial_console.set_linesep(linesep)
             self.serial_console.set_status_test_command(status_test_command)
@@ skipping 53 matching lines @@
 
 
     def get_cpu_count(self):
         """
         Get the cpu count of the VM.
         """
         session = self.remote_login()
         if not session:
             return None
         try:
-            return int(session.cmd(self.params.get("cpu_chk_cmd")))
+            cmd = self.params.get("cpu_chk_cmd")
+            s, count = session.get_command_status_output(cmd)
+            if s == 0:
+                return int(count)
+            return None
         finally:
             session.close()
 
 
     def get_memory_size(self, cmd=None):
         """
         Get bootup memory size of the VM.
 
         @param check_cmd: Command used to check memory. If not provided,
                 self.params.get("mem_chk_cmd") will be used.
         """
         session = self.remote_login()
         if not session:
             return None
         try:
             if not cmd:
                 cmd = self.params.get("mem_chk_cmd")
-            mem_str = session.cmd(cmd)
+            s, mem_str = session.get_command_status_output(cmd)
+            if s != 0:
+                return None
             mem = re.findall("([0-9]+)", mem_str)
             mem_size = 0
             for m in mem:
                 mem_size += int(m)
             if "GB" in mem_str:
                 mem_size *= 1024
             elif "MB" in mem_str:
                 pass
             else:
                 mem_size /= 1024
             return int(mem_size)
         finally:
             session.close()
 
 
     def get_current_memory_size(self):
         """
         Get current memory size of the VM, rather than bootup memory.
         """
         cmd = self.params.get("mem_chk_cur_cmd")
         return self.get_memory_size(cmd)
-
-
-    def save_to_file(self, path):
-        """
-        Save the state of virtual machine to a file through migrate to
-        exec
-        """
-        # Make sure we only get one iteration
-        self.monitor.cmd("migrate_set_speed 1000g")
-        self.monitor.cmd("migrate_set_downtime 100000000")
-        self.monitor.migrate('"exec:cat>%s"' % path)