Merge lp:~mvo/software-center/opengl-driver-blacklist into lp:software-center

[Michael Vogt]

This will add support for video driver blacklisting. It needs a string freeze exception though.

[Gary Lasker (gary-lasker)]

Looks just great, thanks Michael!

review: Approve

=== modified file 'softwarecenter/db/application.py'
--- softwarecenter/db/application.py	2012-03-08 14:36:25 +0000
+++ softwarecenter/db/application.py	2012-03-15 12:47:22 +0000
@@ -821,21 +821,23 @@
     def hardware_requirements(self):
         result = {}
         try:
-            from debtagshw.debtagshw import DebtagsAvailableHW
-            hw = DebtagsAvailableHW()
-            result =  hw.get_hardware_support_for_tags(
-                self.tags)
+            from softwarecenter.hw import get_hardware_support_for_tags
+            result =  get_hardware_support_for_tags(self.tags)
         except ImportError:
             LOG.warn("failed to import debtagshw")
             return result
         return result
 
     def _unavailable_channel(self):
-        """ Check if the given doc refers to a channel that is currently not enabled """
+        """ Check if the given doc refers to a channel that is currently
+            not enabled
+        """
         return not is_channel_available(self.channelname)
 
     def _unavailable_component(self, component_to_check=None):
-        """ Check if the given doc refers to a component that is currently not enabled """
+        """ Check if the given doc refers to a component that is currently 
+            not enabled
+        """
         if component_to_check:
             component = component_to_check
         elif self.component:

=== modified file 'softwarecenter/hw.py'
--- softwarecenter/hw.py	2012-03-02 10:11:09 +0000
+++ softwarecenter/hw.py	2012-03-15 12:47:22 +0000
@@ -18,6 +18,10 @@
 
 from gettext import gettext as _
 
+# private extension over the debtagshw stuff
+OPENGL_DRIVER_BLACKLIST_TAG = "x-hardware::opengl-driver-blacklist:"
+
+
 TAG_DESCRIPTION = {
     'hardware::webcam' : _('webcam'),
     'hardware::digicam' : _('digicam'),
@@ -67,15 +71,57 @@
                                    'drive, but none are currently connected.'),
     'hardware::video:opengl' : _('This computer does not have graphics fast '
                                  'enough for this software.'),
+    # private extension
+    OPENGL_DRIVER_BLACKLIST_TAG: _('This computer uses a "%s" video driver, '
+                                   'but the application is not compatible '
+                                   'with that.'),
 }
 
+def get_hw_short_description(tag):
+    s = TAG_DESCRIPTION.get(tag)
+    return s
+
 def get_hw_missing_long_description(tags):
     s = ""
     # build string
     for tag, supported in tags.iteritems():
         if supported == "no":
-            s += "%s\n" % TAG_MISSING_DESCRIPTION.get(tag)
+            descr = TAG_MISSING_DESCRIPTION.get(tag)
+            if descr:
+                s += "%s\n" % descr
+            else:
+                # deal with generic tags
+                prefix, sep, postfix = tag.rpartition(":")
+                descr =  TAG_MISSING_DESCRIPTION.get(prefix+sep)
+                descr = descr % postfix
+                if descr:
+                    s += "%s\n" % descr
     # ensure that the last \n is gone
     if s:
         s = s[:-1]
     return s
+
+
+def get_private_extenstions_hardware_support_for_tags(tags):
+    import debtagshw
+    res = {}
+    for tag in tags:
+        if tag.startswith(OPENGL_DRIVER_BLACKLIST_TAG):
+            prefix, sep, driver = tag.rpartition(":")
+            if driver == debtagshw.opengl.get_driver():
+                res[tag] = debtagshw.enums.HardwareSupported.NO
+            else:
+                res[tag] = debtagshw.enums.HardwareSupported.YES
+    return res
+
+def get_hardware_support_for_tags(tags):
+    """ wrapper around the DebtagsAvailalbeHW to support adding our own 
+        private tag extension (like opengl-driver)
+    """
+    from debtagshw.debtagshw import DebtagsAvailableHW
+    hw = DebtagsAvailableHW()
+    support = hw.get_hardware_support_for_tags(tags)
+    private_extensions = get_private_extenstions_hardware_support_for_tags(
+        tags)
+    support.update(private_extensions)
+    return support

=== modified file 'softwarecenter/ui/gtk3/widgets/labels.py'
--- softwarecenter/ui/gtk3/widgets/labels.py	2012-03-09 12:50:38 +0000
+++ softwarecenter/ui/gtk3/widgets/labels.py	2012-03-15 12:47:22 +0000
@@ -19,7 +19,7 @@
 from gi.repository import Gtk
 from gettext import gettext as _
 
-from softwarecenter.hw import TAG_DESCRIPTION
+from softwarecenter.hw import get_hw_short_description
 
 
 class HardwareRequirementsLabel(Gtk.HBox):
@@ -70,7 +70,7 @@
             s = self.LABEL
         return _(s) % {
             "sym": sym,
-            "hardware": _(TAG_DESCRIPTION[self.tag]),
+            "hardware": _(get_hw_short_description(self.tag))
             }
 
     def set_hardware_requirement(self, tag, result):
@@ -91,17 +91,15 @@
 
     def set_hardware_requirements(self, hw_requirements_result):
         self.clear()
-        for tag, supported in hw_requirements_result.iteritems():
+        for i, (tag, sup) in enumerate(hw_requirements_result.iteritems()):
             # ignore unknown for now
-            if not supported in ("yes", "no"):
+            if not sup in ("yes", "no"):
                 continue
-            label = HardwareRequirementsLabel(last_item=False)
-            label.set_hardware_requirement(tag, supported)
+            is_last_item = (i == len(hw_requirements_result)-1)
+            label = HardwareRequirementsLabel(last_item=is_last_item)
+            label.set_hardware_requirement(tag, sup)
             label.show()
             self.pack_start(label, True, True, 6)
-        # tell the last item that its last
-        if self.get_children():
-            self.get_children()[-1].last_item = True
 
     @property
     def hw_labels(self):

=== added file 'test/test_hw.py'
--- test/test_hw.py	1970-01-01 00:00:00 +0000
+++ test/test_hw.py	2012-03-15 12:47:22 +0000
@@ -0,0 +1,44 @@
+#!/usr/bin/python
+
+import unittest
+
+from mock import patch
+
+from testutils import setup_test_env
+setup_test_env()
+from softwarecenter.hw import (
+    get_hardware_support_for_tags, 
+    get_hw_missing_long_description,
+    OPENGL_DRIVER_BLACKLIST_TAG)
+
+class TestHW(unittest.TestCase):
+    """ tests the hardware support detection """
+
+    def test_get_hardware_support_for_tags(self):
+        tags = [OPENGL_DRIVER_BLACKLIST_TAG + "intel",
+                "hardware::input:mouse",
+               ]
+        with patch("debtagshw.opengl.get_driver") as mock_get_driver:
+            # test with the intel driver
+            mock_get_driver.return_value = "intel"
+            supported = get_hardware_support_for_tags(tags)
+            self.assertEqual(supported[tags[0]], "no")
+            self.assertEqual(len(supported), 2)
+            # now with fake amd driver
+            mock_get_driver.return_value = "amd"
+            supported = get_hardware_support_for_tags(tags)
+            self.assertEqual(supported[tags[0]], "yes")
+
+    def test_get_hw_missing_long_description(self):
+        s = get_hw_missing_long_description(
+            { "hardware::input:keyboard": "yes",
+              OPENGL_DRIVER_BLACKLIST_TAG + "intel": "no",
+            })
+        self.assertEqual(s, 'This computer uses a "intel" video driver, '
+                         'but the application is not compatible with that.')
+
+
+if __name__ == "__main__":
+    #import logging
+    #logging.basicConfig(level=logging.DEBUG)
+    unittest.main()