Merge lp:~michael.nelson/ubuntu-webcatalog/788210-navigate-distroseries-2 into lp:ubuntu-webcatalog

[Michael Nelson]

Thin out the view code, moving get_user_os into a more readable/testable UserAgentString utility.

Overview
========
This branch refactors more of the view code out into utility classes (get_user_os) to make things a bit more maintainable, but also modifies the behavior of what we display depending on the information we have in the user agent.

Details
=======

I've added a UserAgentString utility, but not yet added explicit tests for it (it is still tested via the view and templatetag tests in the same way as the code that it replaces was. We will need to do this.

I refactored the install_options template tag - it should be pretty self-explanatory now, although I want to check with achuni/danny about the decision for linux users.

I added tests for the template tag directly, removed the corresponding tests from the view tests while leaving 2 functional tests in the view.

To test: follow the readme to bootstrap then `fab test` or you can do an import and test manually for a package that is available on your own distroseries as well as another (chromium sends correct user agent, firefox sends only linux).

The only remaining work to finish bug 788210 is to simply add a section to the app details page that lists links to the app in other series (when available) in a sidebar.

There are other issues that I noticed that we should either create bugs for or fix immediately:
 * When the /cat/application/foopkg/ url is used without the distroseries, we currently blindly redirect to the distroseries specific url (either from teh user agent or the default) without actually knowing if it exists (ie. it could 404). We should instead find the app with the highest released distroseries version and redirect to it (or a default if one is set and available).
 * I personally think we should update the urls to use distroseries versions (/cat/application/foopkg/11.04/ ) for released series (it's an Ubuntu convention to not use code_names after release).

[lp:~michael.nelson/ubuntu-webcatalog/788210-navigate-distroseries-2]

44. By Michael Nelson on 2011-06-29

RED: The link to the users distroseries version should not be escaped.

45. By Michael Nelson on 2011-06-29

GREEN: The link to users distroseries is not escaped (but the application name is).

[Anthony Lenton (elachuni)]

Hi Michael,

+1 to the idea of checking if the app exists at all, and which is the most current distroseries we've got, before blindly redirecting to it.

Hm, and good point about changing codenames for versions too. Let's not worry about these in this branch I'll try to push these two fixes up today in a different branch, together with tests for the UserAgentString utility.

PS: Enjoy your holidays! :)

review: Approve

=== modified file 'src/webcatalog/models/applications.py'
--- src/webcatalog/models/applications.py	2011-06-29 10:04:35 +0000
+++ src/webcatalog/models/applications.py	2011-06-29 15:39:52 +0000
@@ -133,6 +133,10 @@
             args=[self.distroseries.code_name, self.package_name])})
         return crumbs
 
+    @property
+    def architectures_list(self):
+        return self.architectures.split(',')
+
     class Meta:
         app_label = 'webcatalog'
 

=== modified file 'src/webcatalog/templates/webcatalog/install_options_snippet.html'
--- src/webcatalog/templates/webcatalog/install_options_snippet.html	2011-06-29 09:24:48 +0000
+++ src/webcatalog/templates/webcatalog/install_options_snippet.html	2011-06-29 15:39:52 +0000
@@ -1,11 +1,15 @@
-{% if hide_button %}
-{{ message_text }}
-{% else %}
-<a href="apt://{{ application.package_name }}" class="awesome">{{ button_text }} {{ application.name }}</a>
-{% endif %}
-{% if links %}
-{% for text, link in links %}
-    <br><a href="{{link}}" class="awesome">{{ text }}</a>
-{% endfor %}
+{% load i18n %}
+{% if message_text %}
+  {{ message_text }}
+{% endif %}{% if display_install_button %}
+  <a href="apt://{{ application.package_name }}" class="awesome">
+    {% if application.for_purchase %}
+      Purchase {{ application.name }}
+    {% else %}
+      Install {{ application.name }}
+    {% endif %}
+  </a>
+{% endif %}{% if display_ubuntu_download %}
+<a href="http://www.ubuntu.com/download" class="awesome">{% trans "Download Ubuntu" %}</a>
 {% endif %}
 

=== modified file 'src/webcatalog/templatetags/webcatalog.py'
--- src/webcatalog/templatetags/webcatalog.py	2011-06-29 09:24:48 +0000
+++ src/webcatalog/templatetags/webcatalog.py	2011-06-29 15:39:52 +0000
@@ -29,9 +29,12 @@
 
 from django import template
 from django.core.urlresolvers import reverse
+from django.utils.html import escape
+from django.utils.safestring import mark_safe
+from django.utils.translation import ugettext as _
 
 from webcatalog.models import Application
-from webcatalog.views import get_user_os
+from webcatalog.utilities import UserAgentString
 
 register = template.Library()
 
@@ -39,43 +42,67 @@
 @register.inclusion_tag('webcatalog/install_options_snippet.html',
                         takes_context=True)
 def install_options(context, application):
-    app = application
-    os = get_user_os(context['user_agent'])
-    button_text = 'Purchase' if app.for_purchase else 'Install'
-    right_platform = os['is_linux']
-    right_arch = app.architectures.find(os['arch']) > -1
-    right_distro = os['distro'].find(app.distroseries.code_name) > -1
-    perfect_match = (right_platform and right_distro  and right_arch)
-    message_text = 'Not available for your version of Ubuntu'
-    links = []
-    if not perfect_match:
-        if not right_platform:
-            message_text = "Not available for your platform"
-            links.append(('Download Ubuntu', 'http://www.ubuntu.com/download'))
-        elif not right_distro and os['distro_is_a_guess']:
-            # see if we have this package for *other* distros
-            apps_found = Application.objects.filter(
-                package_name=application.package_name).exclude(
-                    distroseries__code_name=os['distro'])
-            if apps_found:
-                message_text = ('Not running %s?' % os['distro'])
-                for app_found in apps_found:
-                    args = [app.distroseries.code_name, app.package_name]
-                    url = reverse('wc-package-detail', args=args)
-                    text = "%s %s for %s" % (button_text, app.name,
-                                          app_found.distroseries.code_name)
-                    links.append((text, url))
-        elif not right_distro:
-            app_found = Application.objects.filter(
+    """Evaluate the installation options for the application in context."""
+    useragent = UserAgentString(context['user_agent'])
+    template_context = dict(application=application, message_text='',
+        display_install_button=False, display_ubuntu_download=False)
+
+    if useragent.distroseries == application.distroseries.code_name:
+        # If both the distroseries and architecture matches, install away,
+        # otherwise if the architecture doesn't match inform the user.
+        for arch in application.architectures_list:
+            if useragent.matches_appinstall_arch(arch):
+                template_context['display_install_button'] = True
+                return template_context
+
+        template_context['message_text'] = _(
+            "{application_name} is not available for "
+            "your computer.").format(application_name=application.name)
+        return template_context
+
+    if useragent.distroseries:
+        # If we know a definitive distroseries but doesn't match the
+        # application being viewed, we check for the app with the users
+        # series and recommend it, or if it doesn't exist, say so.
+        try:
+            Application.objects.get(
                 package_name=application.package_name,
-                distroseries__code_name=os['distro'])
-            if app_found:
-                args = [app.distroseries.code_name, app.package_name]
-                url = reverse('wc-package-detail', args=args)
-                message_text = ('%s is also available for your version '
-                                'of Ubuntu' % app.name)
-                links.append(("%s for os['distro']" % button_text, url))
+                distroseries__code_name=useragent.distroseries)
+            app_in_series_url = reverse(
+                'wc-package-detail',
+                args=[application.package_name, useragent.distroseries])
+            template_context['message_text'] = _(
+                '{application_name} is also available for '
+                '<a href="{app_in_series_url}">your version of '
+                'Ubuntu</a>.').format(
+                    application_name=escape(application.name),
+                    app_in_series_url=app_in_series_url)
+            template_context['message_text'] = mark_safe(
+                template_context['message_text'])
+            return template_context
+        except Application.DoesNotExist:
+            template_context['message_text'] = _(
+                '{application_name} is not available for your version '
+                'of Ubuntu.').format(application_name=application.name)
+            return template_context
 
-    return dict(application=application, button_text=button_text,
-        hide_button=not perfect_match, message_text=message_text,
-        links=links)
+    if useragent.is_linux:
+        # XXX Michael Nelson 2011-06-28 bug=709125
+        # Until we know what our staging/production domains will be and have
+        # ubufox updated similarly to apt.canonical.com as per bug 709125,
+        # we'll only have the correct user-agent for chromium, so we display
+        # the install button for all linux browsers until that is resolved.
+        # For most packages this will not affect ubuntu users at all (as
+        # they are generally arch any and available across
+        # distroseries). When the package doesn't exist for the Ubuntu
+        # users distroseries, they'll simply be told that when software
+        # center opens up. Non-ubuntu/debian users browsers won't
+        # understand the apt url.
+        template_context['display_install_button'] = True
+        return template_context
+    else:
+        template_context['message_text'] = _(
+            '{application_name} is not available for your operating '
+            'system.').format(application_name=application.name)
+        template_context['display_ubuntu_download'] = True
+        return template_context

=== modified file 'src/webcatalog/tests/__init__.py'
--- src/webcatalog/tests/__init__.py	2011-04-13 02:24:17 +0000
+++ src/webcatalog/tests/__init__.py	2011-06-29 15:39:52 +0000
@@ -16,8 +16,9 @@
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
 """Import various view, model and other tests for django's default runner."""
-from .test_forms import *
 from .test_commands import *
-from .test_views import *
 from .test_department_filters import *
+from .test_forms import *
 from .test_models import *
+from .test_templatetags import *
+from .test_views import *

=== added file 'src/webcatalog/tests/test_templatetags.py'
--- src/webcatalog/tests/test_templatetags.py	1970-01-01 00:00:00 +0000
+++ src/webcatalog/tests/test_templatetags.py	2011-06-29 15:39:52 +0000
@@ -0,0 +1,150 @@
+#   -*- coding: utf-8 -*-
+#   This file is part of the Ubuntu Web Catalog
+#   Copyright (C) 2011 Canonical Ltd.
+#
+#   This program is free software: you can redistribute it and/or modify
+#   it under the terms of the GNU Affero General Public License as
+#   published by the Free Software Foundation, either version 3 of the
+#   License, or (at your option) any later version.
+#
+#   This program is distributed in the hope that it will be useful,
+#   but WITHOUT ANY WARRANTY; without even the implied warranty of
+#   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+#   GNU Affero General Public License for more details.
+#
+#   You should have received a copy of the GNU Affero General Public License
+#   along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+"""Tests for the webcatalog template tags."""
+
+from __future__ import (
+    absolute_import,
+    with_statement,
+    )
+
+from django.core.urlresolvers import reverse
+from django.template import Context
+
+from webcatalog.templatetags.webcatalog import install_options
+from webcatalog.tests.factory import TestCaseWithFactory
+
+__metaclass__ = type
+__all__ = [
+    'InstallOptionsTestCase',
+    ]
+
+
+class InstallOptionsTestCase(TestCaseWithFactory):
+
+    def setUp(self):
+        super(InstallOptionsTestCase, self).setUp()
+        self.natty = self.factory.make_distroseries(code_name='natty',
+            version='11.04')
+        self.lucid = self.factory.make_distroseries(code_name='lucid',
+            version='10.04')
+
+    def make_useragent(self, linux=True, arch='x86_64', ubuntu_version=None):
+        os = 'X11; Linux' if linux else 'Windows NT 5.1'
+        version_string = ''
+        if ubuntu_version:
+            version_string = "Ubuntu/" + ubuntu_version
+        return "blah {os} {arch}; {version_string} blah".format(
+            os=os, arch=arch, version_string=version_string)
+
+    def test_matching_series_arch(self):
+        # If the users series and arch match - install.
+        application = self.factory.make_application(
+            package_name='pkgfoo', distroseries=self.natty,
+            arch='amd64')
+        context = Context(
+            dict(user_agent=self.make_useragent(
+                ubuntu_version='11.04', arch='x86_64')))
+
+        self.assertEqual(
+            dict(application=application, display_install_button=True,
+                 message_text='', display_ubuntu_download=False),
+            install_options(context, application))
+
+    def test_matching_series_arch_not_supported(self):
+        # If the users series matches but arch not supported, we let
+        # them know.
+        application = self.factory.make_application(
+            name="Package Foo", package_name='pkgfoo',
+            distroseries=self.natty, arch='i686')
+        context = Context(
+            dict(user_agent=self.make_useragent(
+                ubuntu_version='11.04', arch='solaris')))
+
+        self.assertEqual(dict(
+            application=application, display_install_button=False,
+            message_text='Package Foo is not available for your computer.',
+            display_ubuntu_download=False),
+            install_options(context, application))
+
+    def test_different_series_with_available(self):
+        # If the users series is different from the app, but the app is
+        # available for their series, then we display a link to the app
+        # for their series.
+        natty_application = self.factory.make_application(
+            name="Package Foo", package_name='pkgfoo',
+            distroseries=self.natty)
+        lucid_application = self.factory.make_application(
+            name="Package Foo", package_name='pkgfoo',
+            distroseries=self.lucid)
+        context = Context(
+            dict(user_agent=self.make_useragent(ubuntu_version='10.04')))
+
+        lucid_app_url = reverse('wc-package-detail', args=['pkgfoo', 'lucid'])
+        self.assertEqual(dict(
+            application=natty_application, display_install_button=False,
+            message_text='Package Foo is also available for '
+                         '<a href="{lucid_app_url}">your version of Ubuntu'
+                         '</a>.'.format(lucid_app_url=lucid_app_url),
+            display_ubuntu_download=False),
+            install_options(context, natty_application))
+
+    def test_different_series_without_available(self):
+        # If the users series is different from the app, and the app is
+        # available for their series, then we say so.
+        natty_application = self.factory.make_application(
+            name="Package Foo", package_name='pkgfoo',
+            distroseries=self.natty)
+        context = Context(
+            dict(user_agent=self.make_useragent(ubuntu_version='10.10')))
+
+        self.assertEqual(dict(
+            application=natty_application, display_install_button=False,
+            message_text='Package Foo is not available for your version '
+                         'of Ubuntu.',
+            display_ubuntu_download=False),
+            install_options(context, natty_application))
+
+    def test_linux_only_displays_install_button(self):
+        # XXX Michael Nelson 2011-06-28 bug=709125
+        # If the useragent tells us only Linux, we display the apt link
+        # because until we have ubufox updated for whatever our
+        # webcatalog domain will be (see update for apt.ubuntu.com on
+        # bug 709125) only chromium in natty provides the version in the
+        # user agent.
+        application = self.factory.make_application(package_name='pkgfoo')
+        context = Context(dict(
+            user_agent=self.make_useragent(ubuntu_version='')))
+
+        self.assertEqual(
+            dict(application=application, display_install_button=True,
+                 message_text='', display_ubuntu_download=False),
+            install_options(context, application))
+
+    def test_non_linux_displays_download_ubuntu(self):
+        # A non-linux client is provided a link to download ubuntu.
+        application = self.factory.make_application(
+            package_name='pkgfoo', name="Package Foo")
+        context = Context(dict(
+            user_agent=self.make_useragent(linux=False)))
+
+        self.assertEqual(
+            dict(application=application, display_install_button=False,
+                 message_text='Package Foo is not available for your '
+                              'operating system.',
+                 display_ubuntu_download=True),
+            install_options(context, application))

=== modified file 'src/webcatalog/tests/test_views.py'
--- src/webcatalog/tests/test_views.py	2011-06-29 09:24:48 +0000
+++ src/webcatalog/tests/test_views.py	2011-06-29 15:39:52 +0000
@@ -116,79 +116,23 @@
         self.assertContains(response, 'Purchase %s' % app.name)
         self.assertNotContains(response, 'Install %s' % app.name)
 
-    def test_button_for_matching_distroseries(self):
-        response, app = self.get_app_and_response(for_purchase=True)
-
-        self.assertContains(response, 'Purchase %s' % app.name)
-        self.assertNotContains(response, 'Install %s' % app.name)
-
-    def test_button_for_non_matching_distroseries_but_available(self):
-        series = DistroSeries(code_name='natty', version='11.04')
-        series.save()
-        app2 = self.factory.make_application(package_name='pkgfoo',
-                                            distroseries=series,
-                                            arch='x86_64')
-        app2.save()
-        response, app = self.get_app_and_response(code_name='oneric',
-                                                  version='11.10',
-                                                  for_purchase=True,
-                                                  detail_distro='oneric')
-
-        self.assertContains(response, 'Not running %s?' %
-                            settings.DEFAULT_DISTRO)
-        self.assertContains(response, 'Purchase %s for oneric' % app.name)
-        self.assertContains(response, '/cat/applications/oneric/pkgfoo/')
-
-    @patch('webcatalog.templatetags.webcatalog.get_user_os')
-    def test_button_for_non_matching_distroseries_and_unavailable(self,
-                                                        mock_get_user_os):
-        # patch user agent check so we can have distro is a guess be False
-        # otherwise we'll get the 'Not using natty?' message
-        fake = {'is_linux': True, 'distro': 'natty', 'distro_is_a_guess': False,
-                'arch': 'x86_64'}
-        mock_get_user_os.return_value = fake
-        response, app = self.get_app_and_response(code_name='oneric',
-                                                  version='11.10',
-                                                  for_purchase=True,
-                                                  detail_distro='oneric')
-
-        self.assertNotContains(response, 'Purchase %s' % app.name)
-        not_avail_msg = 'Not available for your version of Ubuntu'
-        self.assertContains(response, not_avail_msg)
-
-    def test_button_for_non_matching_platform(self):
-        response, app = self.get_app_and_response(useragent=WINDOWS_USERAGENT)
-
-        self.assertNotContains(response, 'Purchase %s' % app.name)
-        self.assertContains(response, 'Not available for your platform')
-        self.assertContains(response, 'http://www.ubuntu.com/download')
-        self.assertContains(response, 'Download Ubuntu')
-
-    def test_app_detail_with_no_useragent(self):
-        # don't set the useragent
-        response, app = self.get_app_and_response(useragent=None)
-
-        self.assertNotContains(response, 'Purchase %s' % app.name)
-
-    def test_button_for_non_guessed_match(self):
-        ua = 'blah X11; Linux Ubuntu/11.04 blah blah'
-        response, app = self.get_app_and_response(useragent=ua,
-                                                  for_purchase=True)
-
-        self.assertContains(response, 'Purchase %s' % app.name)
-        self.assertNotContains(response, 'Install %s' % app.name)
-        self.assertNotContains(response, 'Not running %s?' %
-                            settings.DEFAULT_DISTRO)
-
-    def test_button_for_non_guessed_non_match(self):
-        ua = 'blah X11; Linux Ubuntu/11.10 blah blah'
-        response, app = self.get_app_and_response(useragent=ua,
-                                                  for_purchase=True)
-
-        self.assertContains(response, 'Not available for your version of'
-                            ' Ubuntu')
-        self.assertNotContains(response, 'Not running %s?' %
-                            settings.DEFAULT_DISTRO)
+    def test_link_to_different_series(self):
+        # If the users series is different from the app, but the app is
+        # available for their series, then we display a link to the app
+        # for their series.
+        lucid = self.factory.make_distroseries(code_name='lucid',
+            version='10.04')
+        lucid_app = self.factory.make_application(package_name='pkgfoo',
+            distroseries=lucid)
+
+        response, app = self.get_app_and_response(name="<a>Escape me",
+            useragent="blah Ubuntu/10.04 blah")
+
+        lucid_app_url = reverse('wc-package-detail', args=['pkgfoo', 'lucid'])
+        self.assertContains(response,
+            '&lt;a&gt;Escape me is also available for '
+            '<a href="{lucid_app_url}">your version of Ubuntu</a>.'.format(
+                lucid_app_url=lucid_app_url))
 
 
 class ApplicationDetailNoSeriesTestCase(TestCaseWithFactory):

=== modified file 'src/webcatalog/utilities.py'
--- src/webcatalog/utilities.py	2011-06-29 11:41:31 +0000
+++ src/webcatalog/utilities.py	2011-06-29 15:39:52 +0000
@@ -14,18 +14,21 @@
 #   You should have received a copy of the GNU Affero General Public License
 #   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 
-"""SSO/OAuth authenticator for Piston."""
+"""Utilities used by various modules of the web catalog."""
 
 
 from __future__ import absolute_import
 
 __metaclass__ = type
 __all__ = [
+    'full_claimed_id',
+    'UserAgentString',
     'WebServices',
     'WebServiceError',
     ]
 
 import logging
+import re
 import urllib
 from httplib2 import ServerNotFoundError
 
@@ -127,3 +130,57 @@
 def full_claimed_id(consumer_key):
     return '%s/+id/%s' % (settings.OPENID_SSO_SERVER_URL.strip('/'),
         consumer_key)
+
+
+class UserAgentString(object):
+    """A helper object for interrogating a user agent string for info."""
+    def __init__(self, useragent_string):
+        self.useragent_string = useragent_string
+
+    @property
+    def is_linux(self):
+        return self.useragent_string.find('Linux') > -1
+
+    @property
+    def is_ubuntu(self):
+        return self.useragent_string.find('buntu') > 0
+
+    @property
+    def distroseries(self):
+        distros = {
+            '10.04': 'lucid',
+            '10.10': 'maverick',
+            '11.04': 'natty',
+            '11.10': 'oneiric',
+        }
+        match = re.search(
+            "buntu/(?P<version>\d\d\.\d\d)", self.useragent_string)
+        if match:
+            version = match.groupdict()['version']
+            return distros.get(version, None)
+        return None
+
+    @property
+    def linux_arch(self):
+        match = re.search('Linux (?P<arch>\w+)', self.useragent_string)
+        if match:
+            return match.groupdict()['arch']
+        return None
+
+    def matches_appinstall_arch(self, appinstall_arch_tag):
+        # An empty appinstall arch tag implies all arches.
+        if appinstall_arch_tag in ('', 'any', 'all'):
+            return True
+
+        browser_arch = self.linux_arch
+
+        if appinstall_arch_tag == 'i386':
+            return browser_arch in ('i386', 'x86')
+
+        if appinstall_arch_tag in ('ia64', 'amd64'):
+            return browser_arch in ('x86_64', 'i686')
+
+        if appinstall_arch_tag == browser_arch:
+            return True
+
+        return False

=== modified file 'src/webcatalog/views.py'
--- src/webcatalog/views.py	2011-06-29 09:30:53 +0000
+++ src/webcatalog/views.py	2011-06-29 15:39:52 +0000
@@ -40,6 +40,7 @@
     Application,
     Department,
     )
+from webcatalog.utilities import UserAgentString
 
 __metaclass__ = type
 __all__ = [
@@ -109,12 +110,13 @@
 
 
 def application_detail(request, package_name, distro=None):
-    os = get_user_os(request.META.get('HTTP_USER_AGENT', ''))
+
     if distro is None:
+        useragent = UserAgentString(request.META.get('HTTP_USER_AGENT', ''))
         # Check for the distroseries in the useragent, if we have it,
         # redirect there.
-        if not os['distro_is_a_guess'] and os['distro']:
-            distro = os['distro']
+        if useragent.distroseries:
+            distro = useragent.distroseries
         else:
             distro = settings.DEFAULT_DISTRO
         return HttpResponseRedirect(
@@ -127,47 +129,3 @@
     return render_to_response(
         'webcatalog/application_detail.html', RequestContext(
             request, dict(application=app, breadcrumbs=app.crumbs())))
-
-
-def get_user_os(user_agent_string):
-    distros = {
-        '10.04': 'lucid',
-        '10.10': 'maverick',
-        '11.04': 'natty',
-        '11.10': 'oneiric',
-    }
-    os = {
-        'is_linux': False,
-        'distro': '',
-        'arch': '',
-        'distro_is_a_guess': False,
-        }
-    ua = user_agent_string
-    if not ua:
-        return os
-    os['is_linux'] = ua.find('X11; Linux') > -1
-    if os['is_linux']:
-        os['distro'] = settings.DEFAULT_DISTRO
-        os['distro_is_a_guess'] = True
-        # Some browsers will have a patch that will actually give us the distro
-        if ua.find('buntu') > -1:
-            os['distro_is_a_guess'] = False
-            slash = ua.find('/', ua.find('buntu'))
-            if slash > -1:
-                version = ua[slash + 1: slash + 6]
-                distro = distros[version]
-                if distro:
-                    os['distro'] = distro
-                    os['distro_is_a_guess'] = False
-    else:
-        os['distro'] = ''
-        os['distro_is_a_guess'] = False
-
-    is_x86_64 = ua.find('x86_64')
-    is_686 = ua.find('i686')
-    if is_x86_64:
-        os['arch'] = 'x86_64'
-    elif is_686:
-        os['arch'] = 'i686'
-    # TODO: DT Get other architectures
-    return os