Merge lp:~pawciobiel/testdrive/1297377-fix-kvm-img-not-found-report-error into lp:testdrive

[pawciobiel]

merge fix for lp:1297377

* fix virt.kvm so it checks if qemu-img or kvm-img is installed
* check if qemu-utils is installed when user selected kvm
* tide up virt a bit so testdrive-gtk can notify user about errors

[Andres Rodriguez (andreserl)]

lgtm!

review: Approve

=== modified file 'bin/testdrive'
--- bin/testdrive	2013-10-24 02:11:50 +0000
+++ bin/testdrive	2014-09-13 13:13:23 +0000
@@ -74,8 +74,12 @@
             logger.error(_("\nERROR: Invalid input\n"))
             continue
         if choice == i:
-            url = raw_input(_("\nEnter an ISO URL to testdrive: "))
-            break
+            try:
+                url = raw_input(_("\nEnter an ISO URL to testdrive: "))
+                break
+            except KeyboardInterrupt:
+                print("\n")
+                exit(0)
         elif choice in range(1, i):
             url = menu[choice-1]["url"]
             td.ISO_PATH_HEADER = menu[choice-1]["cat"]
@@ -85,7 +89,7 @@
     return(url)
 
 def error(str):
-    logger.error(_("\n%s\n") % str)
+    logger.error("\n%s\n" % str)
     sys.exit(1)
 
 def is_iso(file):
@@ -401,14 +405,15 @@
     logger.info(_("Validating Virtualization Method...."))
     try:
         virt.validate_virt()
-    except:
-        error(_("Unable to validate Virtualization Method [%s]") % td.VIRT)
+    except Exception as exc:
+        error(_("Unable to validate Virtualization Method [%s] (%s)") % \
+              (td.VIRT, exc))
 
     logger.info(_("Setting up Virtual Machine..."))
     try:
         virt.setup_virt()
-    except:
-        error(_("Unable to setup Virtual Machine"))
+    except Exception as exc:
+        error(_("Unable to setup Virtual Machine (%s)") % exc)
 
     logger.info(_("Launching Virtual Machine..."))
     try:
@@ -417,8 +422,8 @@
         if td.VIRT == "kvm":
             logging.debug("%s:%s" % (time.strftime("%Y-%m-%d_%H:%M:%S"), cmd))
         run_vm(cmd, td, cloud_curses)
-    except:
-        error(_("Unable to launch Virtual Machine"))
+    except Exception as exc:
+        error(_("Unable to launch Virtual Machine (%s)") % (exc))
 
     rm_disk = td.delete_image()
     if rm_disk:
 
=== modified file 'bin/testdrive-gtk'
--- bin/testdrive-gtk	2013-11-17 08:19:27 +0000
+++ bin/testdrive-gtk	2014-09-13 13:13:23 +0000
@@ -739,10 +739,9 @@
             if self.td.VIRT == "virtualbox":
                 logging.info(_("Using VirtualBox for virtual machine hosting..."))
                 virt = virtualbox.VBox(self.td)
-            if self.td.VIRT == "paralels":
+            if self.td.VIRT == "parallels":
                 logging.info(_("Using Parallels Desktop for virtual machine hosting..."))
                 virt = parallels.Parallels(self.td)
-
             # Passing VIRT object to ISOLIST
             ISOLIST[vm_id]["virt"] = virt
             ISOLIST[vm_id]["virt_type"] = self.td.VIRT
@@ -924,20 +923,24 @@
         self.p = None
 
     def prepare_to_launch_vm(self):
-                ###################################################################
-                ######## Prepare the VM to launch and return launch command #######
-                ###################################################################
-        # TODO TODO TODO - Re-add validation
-        self.ovirt.validate_virt()
-        self.ovirt.setup_virt()
-        return self.ovirt.launch_virt()
-
-    def run(self):
-        if self.virt == "virtualbox":
-            text = _("    Configuring Virtual Machine...")
+        """Prepare the VM to launch and return launch command"""
+        try:
+            self.ovirt.validate_virt()
+            self.ovirt.setup_virt()
+            return self.ovirt.launch_virt()
+        except Exception as exc:
+            text = _("Error preparing virtualization: %s") % (exc)
             self.status_label.set_markup("<b><i>%s</i></b>" % text)
             self.status_label.show()
+            logging.error("%s", exc, exc_info=1)
+
+    def run(self):
+        text = _("    Configuring Virtual Machine...")
+        self.status_label.set_markup("<b><i>%s</i></b>" % text)
+        self.status_label.show()
         command = self.prepare_to_launch_vm()
+        if not command: return
+        logger.info("Running VM command %s", command)
         cmd = command.split()
         self.p = subprocess.Popen(cmd, stdout=subprocess.PIPE)
         text = _("     Running Virtual Machine...")
@@ -948,6 +951,7 @@
             while not self.stopthread.isSet():
                 if self.p.poll() != None:
                     self.status_label.set_markup("<i>%s</i>" % self.previous_text)
+                    self.status_label.show()
                     self.p = None
                     break
                 time.sleep(0.1)
@@ -969,6 +973,7 @@
                     break
                 time.sleep(2)
 
+
     def stop(self):
         try:
             if self.p.poll() is None:
 
=== added file 'testdrive/virt/base.py'
--- testdrive/virt/base.py	1970-01-01 00:00:00 +0000
+++ testdrive/virt/base.py	2014-09-13 13:13:23 +0000
@@ -0,0 +1,16 @@
+
+import os
+
+
+class VirtException(Exception):
+    pass
+
+
+class VirtBase(object):
+
+    def run(self, cmd):
+        return(os.system(cmd))
+
+    def run_or_die(self, cmd):
+        if self.run(cmd) != 0:
+            raise VirtException("Failed executing command: `%s`" % cmd)
 
=== modified file 'testdrive/virt/kvm.py'
--- testdrive/virt/kvm.py	2013-05-20 17:12:31 +0000
+++ testdrive/virt/kvm.py	2014-09-13 13:13:23 +0000
@@ -19,10 +19,15 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import sys
 import commands, os, uuid, logging
 
+from .base import VirtException
+
+
 logger = logging.getLogger("testdrive.virt.kvm")
 
+
 class KVM:
 
     def __init__(self, td):
@@ -45,19 +50,35 @@
     def validate_virt(self):
         (status, output) = commands.getstatusoutput("kvm-ok")
         if status != 0:
-            logger.info(output)
+            logger.warn("kvm-ok failed: %s", output)
+        (status, output) = commands.getstatusoutput("dpkg -l qemu-utils")
+        if status != 0:
+            raise VirtException("Package qemu-utils is not installed.")
+
+    def get_kvm_img_path(self):
+        """Get kvm-img or qemu-img path and return it.
+
+            Fall back to deprecated kvm-img. It may appear to be better
+            to call just `which qemu-img kvm-img` but this way is cleaner.
+        """
+        for cmd in ['qemu-img', 'kvm-img']:
+            status, output = commands.getstatusoutput('which %s' % (cmd))
+            if status == 0 and output:
+                return output.strip()
+        raise VirtException("Can not find qemu-img nor kvm-img!")
 
     # Code to setup virtual machine
     def setup_virt(self):
+        kvm_img = self.get_kvm_img_path()
         if self.p == 'cloud-daily' or self.p == 'cloud-releases':
             #path = "%s/%s" % (self.CACHE_ISO, self.PATH_TO_ISO.split(".tar.gz")[0].split("_")[-1])
             path = "%s/%s" % (self.CACHE_ISO, os.path.basename(self.PATH_TO_ISO).split(".tar.gz")[0])
             self.ORIG_DISK = "%s.img" % path
             self.FLOPPY_FILE = "%s-floppy" % path
-            self.run_or_die("kvm-img create -f qcow2 -b %s %s" % (self.ORIG_DISK, self.DISK_FILE))
+            self.run_or_die("%s create -f qcow2 -b %s %s" % (kvm_img, self.ORIG_DISK, self.DISK_FILE))
         elif not os.path.exists(self.DISK_FILE) or self.is_disk_empty():
             logger.info("Creating disk image [%s]..." % self.DISK_FILE)
-            self.run_or_die("kvm-img create -f qcow2 %s %s" % (self.DISK_FILE, self.DISK_SIZE))
+            self.run_or_die("%s create -f qcow2 %s %s" % (kvm_img, self.DISK_FILE, self.DISK_SIZE))
 
     # Code launch virtual machine
     def launch_virt(self):
@@ -68,10 +89,3 @@
         else:
             cmd = "qemu-system-x86_64 -uuid %s -m %s -smp %s -cdrom %s -drive file=%s,if=virtio,cache=writeback,index=0 %s" % (UUID, self.MEM, self.SMP, self.PATH_TO_ISO, self.DISK_FILE, self.KVM_ARGS)
         return cmd
-
-    def run(self, cmd):
-        return(os.system(cmd))
-
-    def run_or_die(self, cmd):
-        if self.run(cmd) != 0:
-            logger.error("Command failed\n    `%s`" % cmd)
 
=== modified file 'testdrive/virt/parallels.py'
--- testdrive/virt/parallels.py	2012-04-21 02:05:42 +0000
+++ testdrive/virt/parallels.py	2014-09-13 13:13:23 +0000
@@ -19,9 +19,16 @@
 #    You should have received a copy of the GNU General Public License
 #    along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
+import logging
 import commands, os, time
 
-class Parallels:
+from .base import VirtBase, VirtException
+
+
+logger = logging.getLogger(__name__)
+
+
+class Parallels(VirtBase):
 
     def __init__(self, td):
         self.HOME = td.HOME
@@ -32,8 +39,11 @@
         self.DISK_SIZE = td.DISK_SIZE
         self.VBOX_NAME = td.VBOX_NAME
 
-    # Code to validate if virtualization is installed/supported
     def validate_virt(self):
+        """validate if virtualization is installed/supported"""
+        if commands.getstatusoutput("which prlctl")[0] != 0:
+            raise VirtException("prlctl not found")
+
         if commands.getstatusoutput("prlctl list %s | grep -qsv \"UUID\"" % self.VBOX_NAME)[0] == 0:
             self.run_or_die("prlctl delete %s" % self.VBOX_NAME)
 
@@ -55,11 +65,3 @@
         # Loop as long as this VM is running
         #while commands.getstatusoutput("prlctl list %s | grep -qs stopped" % self.td.VBOX_NAME)[0] != 0:
         #   time.sleep(2)
-
-    def run(self, cmd):
-        return(os.system(cmd))
-
-    def run_or_die(self, cmd):
-        if self.run(cmd) != 0:
-            #error("Command failed\n    `%s`" % cmd)
-            print "Command failed\n    `%s`" % cmd
 
=== modified file 'testdrive/virt/virtualbox.py'
--- testdrive/virt/virtualbox.py	2013-10-28 19:55:24 +0000
+++ testdrive/virt/virtualbox.py	2014-09-13 13:13:23 +0000
@@ -21,9 +21,13 @@
 
 import commands, os, time, logging
 
+from .base import VirtException, VirtBase
+
+
 logger = logging.getLogger("testdrive.virt.vbox")
 
-class VBox:
+
+class VBox(VirtBase):
 
     def __init__(self, td):
         self.vboxversion = None
@@ -42,19 +46,32 @@
             return True
         return False
 
+    def get_vboxversion(self):
+        status, verstr = commands.getstatusoutput("VBoxManage --version")
+        if status != 0:
+            raise VirtException("No VirtualBox found")
+        try:
+            self.vboxversion = (int(verstr.split(".")[0]),
+                                int(verstr.split(".")[1]))
+        except (IndexError, ValueError) as exc:
+            raise VirtException("Can not extract version "
+                                "[VBoxManage --version]")
+
+
     # Code to validate if virtualization is installed/supported
     def validate_virt(self):
         # Determine which version of VirtualBox we have installed.  What is returned is
         # typically a string such as '4.1.0r55467', lets assume that the command line
         # is consistent within 4.x.x versions extract this part of the
         # version string for comparison later
-        self.vboxversion = commands.getoutput("VBoxManage --version")
-        self.vboxversion = ( int(self.vboxversion.split(".")[0]), int(self.vboxversion.split(".")[1]) )
-        if self.vboxversion == (4,0) or self.vboxversion == (4,1) or self.vboxversion == (4,2) or self.vboxversion == (4,3):
+        self.vboxversion = self.get_vboxversion()
+        supported_versions = ((4,0), (4,1), (4,2), (4,3))
+        if self.vboxversion in supported_versions:
             logger.info("VirtualBox %s.%s detected." % self.vboxversion)
         else:
-            logger.error("ERROR: Unsupported version (%s.%s) of VirtualBox; please install v4.0 or newer." % self.vboxversion)
-            exit(0)
+            err_text = ("Unsupported version (%s.%s) of VirtualBox; "
+                         "please install v4.0 or newer.") % self.vboxversion
+            raise VirtException(err_text)
 
     # Code to setup virtual machine
     def setup_virt(self):
@@ -104,10 +121,3 @@
         # Loop as long as this VM is running
         #while commands.getstatusoutput("VBoxManage list runningvms | grep -qs %s" % self.td.VBOX_NAME)[0] == 0:
         #   time.sleep(2)
-
-    def run(self, cmd):
-        return(os.system(cmd))
-
-    def run_or_die(self, cmd):
-        if self.run(cmd) != 0:
-            logger.error("Command failed\n    `%s`" % cmd)
 
=== modified file 'testdrivegtk/PreferencesTestdrivegtkDialog.py'
--- testdrivegtk/PreferencesTestdrivegtkDialog.py	2013-10-24 14:10:11 +0000
+++ testdrivegtk/PreferencesTestdrivegtkDialog.py	2014-09-13 13:13:23 +0000
@@ -481,7 +481,7 @@
                 path = "%s/%s" % (cache_path, file)
                 os.unlink(path)
         except:
-            on_error_dlg(_("Unable to clean up files from [%s]") % cache_path)
+            self.on_error_dlg(_("Unable to clean up files from [%s]") % cache_path)
     
     def on_select_iso_image_repo(self, widget):
         ##################################################################