Merge lp:~blake-rouse/maas/osystem-registry into lp:~maas-committers/maas/trunk

[Blake Rouse]

Added OperatingSystem, OperatingSystemRegistry, and UbuntuOS class.

This is the second change in the series of changes to all MAAS to deploy other operating systems. As we have Windows and CentOS support coming soon this is needed to easily add new operating systems.

Adds an OperatingSystem class that each supported operating system extends, to provide information about that operating system. Each OperatingSystem class gets registered in the OperatingSystemRegistry so the code base can find the supported operating systems. When finished this will remove the need for DISTRO_SERIES enums.

Added the UbuntuOS class, that provides the information for Ubuntu. Currently this class hard codes the releases that it supports and its purposes for each, but it could pull this data from simplestreams allowing new releases without modifying the code base.

Note: osystem was used throughout the code instead of os, as the python os module would conflict throughout the code base.

Changes were coordinated with allenap.

[Julian Edwards (julian-edwards)]

Phew, took me a while to get through this. It mostly looks great, some minor
improvements can be made, but [4] and [5] are blockers for landing.

It's heading in the right direction though!

[1]

  === modified file 'src/maasserver/templates/maasserver/bootimage-list.html'
  --- src/maasserver/templates/maasserver/bootimage-list.html 2014-04-23 16:09:39 +0000
  +++ src/maasserver/templates/maasserver/bootimage-list.html 2014-04-28 05:57:14 +0000
  @@ -33,7 +33,7 @@
           {% for bootimage in bootimage_list %}
             <tr class="bootimage {% cycle 'even' 'odd' %}">
               <td>{{ bootimage.id }}</td>
  - <td>{{ bootimage.osystem }}</td>
  + <td>{{ bootimage.osystem_title }}</td>
               <td>{{ bootimage.release }}</td>
               <td>{{ bootimage.architecture }}</td>
               <td>{{ bootimage.subarchitecture }}</td>

This change needs a test in test_contains_boot_image_list().

[2]

  +def make_osystem_with_releases(testcase, with_releases=True, osystem_name=None,
  + releases=None):
  + """Generate an arbitrary operating system.
  +
  + :param with_releases: Should the operating system include releases?
  + Defaults to `True`.

There's a few params left to document :)

  + """
  + if osystem_name is None:
  + osystem_name = factory.make_name('os')
  + if with_releases:
  + if releases is None:
  + releases = [factory.make_name('release') for _ in range(3)]

I would simplify the parameters here and omit the "with_releases" parameter and
just allow callers to say releases=[].

Then the code becomes:
 ...

review: Needs Fixing

[Jeroen T. Vermeulen (jtv)]

One question, which came up with other registries as well: does OperatingSystem really need a class hierarchy? If a simple class with plain objects will do, prefer simplicity.

The RPC API is not meant to be public or backwards-compatible for now, so we don't need to engineer this for a future that is hard to predict in detail. We can embellish and refactor as the need arises.

[Jeroen T. Vermeulen (jtv)]

By the way, dromedary-case method names like getRandomOS are sort of a legacy thing in MAAS. We would now call that make_OS.

[Blake Rouse (blake-rouse)]

Fixed 1,2,3,6,8,10,13,14.

[4] Spoke with Gavin and Andres. Keeping it as is for now as this will be backported into 1.5 for SRU. Will do another branch for trunk that will use RPC, and remove importing from pserv.

[5] Removed title, going back the previous way. Looks just as good, no need to import from pserv.

[7] Leaving as is for now, will move in later branch.

[11,12] Moved the OperatingSystem and OperatingSystemRegistry into the drivers/__init__.py. Removed the need for the osystems folder. The UbuntuOS is now in os_ubuntu.py under drivers, each new os can be labeled os_{{name}}.py

[Julian Edwards (julian-edwards)]

Thanks for all the fixes, it's looking much better. I'll mark it approved with some conditions as below as I know you're trying to get all this done for ODS.

I am not comfortable with leaving [4] only in trunk because there is always the risk that future SRUs/MREs will get rejected and then an LTS is stuck with code that won't work as required. However I think the risk is minimal here. Having said that, please do the RPC stuff in trunk as the simplest change that you can do and then it should backport cleanly to 1.5 as and when required.

For every fix that is being deferred, please file a bug with the description, tag it "tech-debt" and then refer to it with an XXX in the code like this:

   # XXX 2014-05-05 blake-rouse bug=NNNNNNN
   # Doing >blah< later.

So hopefully that means things won't get forgotten.

You didn't mention [9] in your response, are you willing to do that now or defer to a later branch? I think it's worth doing, the code will be much cleaner.

review: Approve

[Blake Rouse (blake-rouse)]

[4] Add bug comment to fix later.

[9] I will also fix in a later branch.

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2014-05-13 18:43:40 +0000
+++ src/maasserver/testing/factory.py	2014-05-13 18:46:09 +0000
@@ -60,6 +60,10 @@
     )
 from netaddr import IPAddress
 
+# XXX 2014-05-13 blake-rouse bug=1319143
+# Need to not import directly, use RPC to info from cluster.
+from provisioningserver.driver import OperatingSystemRegistry
+
 # We have a limited number of public keys:
 # src/maasserver/tests/data/test_rsa{0, 1, 2, 3, 4}.pub
 MAX_PUBLIC_KEYS = 5
@@ -140,6 +144,21 @@
             [choice for choice in list(get_power_types().keys())
                 if choice not in but_not])
 
+    def getRandomOS(self):
+        """Pick a random operating system from the registry."""
+        osystems = [obj for _, obj in OperatingSystemRegistry]
+        return random.choice(osystems)
+
+    def getRandomRelease(self, osystem):
+        """Pick a random release from operating system."""
+        releases = osystem.get_supported_releases()
+        return random.choice(releases)
+
+    def getRandomCommissioningRelease(self, osystem):
+        """Pick a random commissioning release from operating system."""
+        releases = osystem.get_supported_commissioning_releases()
+        return random.choice(releases)
+
     def _save_node_unchecked(self, node):
         """Save a :class:`Node`, but circumvent status transition checks."""
         valid_initial_states = NODE_TRANSITIONS[None]
 
=== added file 'src/maasserver/testing/osystems.py'
--- src/maasserver/testing/osystems.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/testing/osystems.py	2014-05-13 18:46:09 +0000
@@ -0,0 +1,90 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Helpers for operating systems in testing."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    'make_usable_osystem',
+    'patch_usable_osystems',
+    ]
+
+from random import randint
+
+from maasserver import forms
+from maasserver.testing.factory import factory
+from provisioningserver.driver import BOOT_IMAGE_PURPOSE
+from provisioningserver.boot.tests.test_tftppath import make_osystem
+
+
+def make_osystem_with_releases(testcase, osystem_name=None, releases=None):
+    """Generate an arbitrary operating system.
+
+    :param osystem_name: The operating system name. Useful in cases where
+        we need to test that not supplying an os works correctly.
+    :param releases: The list of releases name. Useful in cases where
+        we need to test that not supplying a release works correctly.
+    """
+    if osystem_name is None:
+        osystem_name = factory.make_name('os')
+    if releases is None:
+        releases = [factory.make_name('release') for _ in range(3)]
+
+    osystem = make_osystem(
+        testcase,
+        osystem_name,
+        [BOOT_IMAGE_PURPOSE.INSTALL, BOOT_IMAGE_PURPOSE.XINSTALL])
+    if releases is not None and releases != []:
+        osystem.fake_list = releases
+    return osystem
+
+
+def patch_usable_osystems(testcase, osystems=None, allow_empty=True):
+    """Set a fixed list of usable operating systems.
+
+    A usable operating system is one for which boot images are available.
+
+    :param testcase: A `TestCase` whose `patch` this function can use.
+    :param osystems: Optional list of operating systems.  If omitted,
+        defaults to a list (which may be empty) of random operating systems.
+    """
+    start = 0
+    if allow_empty is False:
+        start = 1
+    if osystems is None:
+        osystems = [
+            make_osystem_with_releases(testcase)
+            for _ in range(randint(start, 2))
+            ]
+    distro_series = {}
+    for osystem in osystems:
+        distro_series[osystem.name] = osystem.get_supported_releases()
+    testcase.patch(forms, 'list_all_usable_osystems').return_value = osystems
+    testcase.patch(
+        forms, 'list_all_usable_releases').return_value = distro_series
+
+
+def make_usable_osystem(testcase, osystem_name=None, releases=None):
+    """Return arbitrary operating system, and make it "usable."
+
+    A usable operating system is one for which boot images are available.
+
+    :param testcase: A `TestCase` whose `patch` this function can pass to
+        `patch_usable_osystems`.
+    :param osystem_name: The operating system name. Useful in cases where
+        we need to test that not supplying an os works correctly.
+    :param releases: The list of releases name. Useful in cases where
+        we need to test that not supplying a release works correctly.
+    """
+    osystem = make_osystem_with_releases(
+        testcase, osystem_name=osystem_name, releases=releases)
+    patch_usable_osystems(testcase, [osystem])
+    return osystem
 
=== modified file 'src/maasserver/views/tests/test_boot_image_list.py'
--- src/maasserver/views/tests/test_boot_image_list.py	2014-04-24 13:52:17 +0000
+++ src/maasserver/views/tests/test_boot_image_list.py	2014-05-13 18:46:09 +0000
@@ -22,16 +22,22 @@
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
 from maasserver.views.clusters import BootImagesListView
+from provisioningserver.boot.tests.test_tftppath import make_osystem
 from testtools.matchers import ContainsAll
 
 
 class BootImageListTest(MAASServerTestCase):
 
+    def setUp(self):
+        super(BootImageListTest, self).setUp()
+
     def test_contains_boot_image_list(self):
         self.client_log_in(as_admin=True)
         nodegroup = factory.make_node_group()
-        images = [
+        boot_images = [
             factory.make_boot_image(nodegroup=nodegroup) for _ in range(3)]
+        for bi in boot_images:
+            make_osystem(self, bi.osystem, ['install'])
         response = self.client.get(
             reverse('cluster-bootimages-list', args=[nodegroup.uuid]))
         self.assertEqual(
@@ -44,8 +50,9 @@
                 image.release,
                 image.subarchitecture,
                 image.architecture,
+                image.osystem,
                 '%s' % image.updated.year,
-            ] for image in images]
+            ] for image in boot_images]
         self.assertThat(
             response.content, ContainsAll(itertools.chain(*items_in_page)))
 
@@ -54,7 +61,12 @@
         self.client_log_in(as_admin=True)
         nodegroup = factory.make_node_group()
         # Create 4 images.
-        [factory.make_boot_image(nodegroup=nodegroup) for _ in range(4)]
+        boot_images = [
+            factory.make_boot_image(nodegroup=nodegroup)
+            for _ in range(4)
+            ]
+        for bi in boot_images:
+            make_osystem(self, bi.osystem, ['install'])
         response = self.client.get(
             reverse('cluster-bootimages-list', args=[nodegroup.uuid]))
         self.assertEqual(httplib.OK, response.status_code)
@@ -65,7 +77,9 @@
 
     def test_displays_warning_if_boot_image_list_is_empty(self):
         # Create boot images in another nodegroup.
-        [factory.make_boot_image() for _ in range(3)]
+        boot_images = [factory.make_boot_image() for _ in range(3)]
+        for bi in boot_images:
+            make_osystem(self, bi.osystem, ['install'])
         self.client_log_in(as_admin=True)
         nodegroup = factory.make_node_group()
         response = self.client.get(
 
=== modified file 'src/maasserver/views/tests/test_clusters.py'
--- src/maasserver/views/tests/test_clusters.py	2014-04-24 13:52:17 +0000
+++ src/maasserver/views/tests/test_clusters.py	2014-05-13 18:46:09 +0000
@@ -41,6 +41,7 @@
     ANY,
     call,
     )
+from provisioningserver.boot.tests.test_tftppath import make_osystem
 from testtools.matchers import (
     AllMatch,
     Contains,
@@ -309,7 +310,12 @@
     def test_contains_link_to_boot_image_list(self):
         self.client_log_in(as_admin=True)
         nodegroup = factory.make_node_group()
-        [factory.make_boot_image(nodegroup=nodegroup) for _ in range(3)]
+        boot_images = [
+            factory.make_boot_image(nodegroup=nodegroup)
+            for _ in range(3)
+            ]
+        for bi in boot_images:
+            make_osystem(self, bi.osystem, ['install'])
         response = self.client.get(
             reverse('cluster-edit', args=[nodegroup.uuid]))
         self.assertEqual(
@@ -320,7 +326,9 @@
 
     def test_displays_warning_if_boot_image_list_is_empty(self):
         # Create boot images in another nodegroup.
-        [factory.make_boot_image() for _ in range(3)]
+        boot_images = [factory.make_boot_image() for _ in range(3)]
+        for bi in boot_images:
+            make_osystem(self, bi.osystem, ['install'])
         self.client_log_in(as_admin=True)
         nodegroup = factory.make_node_group()
         response = self.client.get(
 
=== modified file 'src/provisioningserver/boot/__init__.py'
--- src/provisioningserver/boot/__init__.py	2014-04-23 16:09:39 +0000
+++ src/provisioningserver/boot/__init__.py	2014-05-13 18:46:09 +0000
@@ -168,7 +168,7 @@
         """
         def image_dir(params):
             return compose_image_path(
-                'ubuntu', params.arch, params.subarch,
+                params.osystem, params.arch, params.subarch,
                 params.release, params.label)
 
         def initrd_path(params):
 
=== modified file 'src/provisioningserver/boot/tests/test_pxe.py'
--- src/provisioningserver/boot/tests/test_pxe.py	2014-04-23 16:09:39 +0000
+++ src/provisioningserver/boot/tests/test_pxe.py	2014-05-13 18:46:09 +0000
@@ -163,7 +163,7 @@
         self.assertThat(output, StartsWith("DEFAULT "))
         # The PXE parameters are all set according to the options.
         image_dir = compose_image_path(
-            osystem='ubuntu', arch=params.arch, subarch=params.subarch,
+            osystem=params.osystem, arch=params.arch, subarch=params.subarch,
             release=params.release, label=params.label)
         self.assertThat(
             output, MatchesAll(
@@ -243,9 +243,11 @@
         method = PXEBootMethod()
         get_ephemeral_name = self.patch(kernel_opts, "get_ephemeral_name")
         get_ephemeral_name.return_value = factory.make_name("ephemeral")
+        osystem = factory.make_name('osystem')
         options = {
             "kernel_params": make_kernel_parameters(
-                testcase=self, subarch="generic", purpose=self.purpose),
+                testcase=self, osystem=osystem, subarch="generic",
+                purpose=self.purpose),
         }
         output = method.render_config(**options)
         config = parse_pxe_config(output)
@@ -269,7 +271,7 @@
             self.assertThat(
                 section, ContainsAll(("KERNEL", "INITRD", "APPEND")))
             contains_arch_path = StartsWith(
-                "ubuntu/%s/" % section_label)
+                "%s/%s/" % (osystem, section_label))
             self.assertThat(section["KERNEL"], contains_arch_path)
             self.assertThat(section["INITRD"], contains_arch_path)
             self.assertIn("APPEND", section)
 
=== modified file 'src/provisioningserver/boot/tests/test_tftppath.py'
--- src/provisioningserver/boot/tests/test_tftppath.py	2014-04-23 16:09:39 +0000
+++ src/provisioningserver/boot/tests/test_tftppath.py	2014-05-13 18:46:09 +0000
@@ -30,6 +30,10 @@
     list_subdirs,
     locate_tftp_path,
     )
+from provisioningserver.driver import (
+    OperatingSystem,
+    OperatingSystemRegistry,
+    )
 from provisioningserver.testing.boot_images import (
     make_boot_image_storage_params,
     )
@@ -41,6 +45,40 @@
 from testtools.testcase import ExpectedException
 
 
+class FakeOS(OperatingSystem):
+
+    name = ""
+    title = ""
+
+    def __init__(self, name, purpose, releases=None):
+        self.name = name
+        self.title = name
+        self.purpose = purpose
+        if releases is None:
+            self.fake_list = [
+                factory.getRandomString()
+                for _ in range(3)
+                ]
+        else:
+            self.fake_list = releases
+
+    def get_boot_image_purposes(self, *args):
+        return self.purpose
+
+    def get_supported_releases(self):
+        return self.fake_list
+
+    def get_default_release(self):
+        return self.fake_list[0]
+
+    def format_release_choices(self, releases):
+        return [
+            (release, release)
+            for release in releases
+            if release in self.fake_list
+            ]
+
+
 def make_image(params, purpose):
     """Describe an image as a dict similar to what `list_boot_images` returns.
 
@@ -51,6 +89,29 @@
     return image
 
 
+def make_osystem(testcase, osystem, purpose):
+    """Makes the operating system class and registers it."""
+    if osystem not in OperatingSystemRegistry:
+        fake = FakeOS(osystem, purpose)
+        OperatingSystemRegistry.register_item(fake.name, fake)
+        testcase.addCleanup(
+            OperatingSystemRegistry.unregister_item, osystem)
+        return fake
+
+    else:
+
+        obj = OperatingSystemRegistry[osystem]
+        old_func = obj.get_boot_image_purposes
+        testcase.patch(obj, 'get_boot_image_purposes').return_value = purpose
+
+        def reset_func(obj, old_func):
+            obj.get_boot_image_purposes = old_func
+
+        testcase.addCleanup(reset_func, obj, old_func)
+
+        return obj
+
+
 class TestTFTPPath(MAASTestCase):
 
     def setUp(self):
@@ -123,22 +184,31 @@
         params = make_boot_image_storage_params()
         self.make_image_dir(params, self.tftproot)
         purposes = ['install', 'commissioning', 'xinstall']
+        make_osystem(self, params['osystem'], purposes)
         self.assertItemsEqual(
             [make_image(params, purpose) for purpose in purposes],
             list_boot_images(self.tftproot))
 
     def test_list_boot_images_enumerates_boot_images(self):
+        purposes = ['install', 'commissioning', 'xinstall']
         params = [make_boot_image_storage_params() for counter in range(3)]
         for param in params:
             self.make_image_dir(param, self.tftproot)
+            make_osystem(self, param['osystem'], purposes)
         self.assertItemsEqual(
             [
                 make_image(param, purpose)
                 for param in params
-                for purpose in ['install', 'commissioning', 'xinstall']
+                for purpose in purposes
             ],
             list_boot_images(self.tftproot))
 
+    def test_list_boot_images_empty_on_missing_osystems(self):
+        params = [make_boot_image_storage_params() for counter in range(3)]
+        for param in params:
+            self.make_image_dir(param, self.tftproot)
+        self.assertItemsEqual([], list_boot_images(self.tftproot))
+
     def test_is_visible_subdir_ignores_regular_files(self):
         plain_file = self.make_file()
         self.assertFalse(
 
=== modified file 'src/provisioningserver/boot/tests/test_uefi.py'
--- src/provisioningserver/boot/tests/test_uefi.py	2014-04-23 16:09:39 +0000
+++ src/provisioningserver/boot/tests/test_uefi.py	2014-05-13 18:46:09 +0000
@@ -73,7 +73,7 @@
         self.assertThat(output, StartsWith("set default=\"0\""))
         # The UEFI parameters are all set according to the options.
         image_dir = compose_image_path(
-            osystem='ubuntu', arch=params.arch, subarch=params.subarch,
+            osystem=params.osystem, arch=params.arch, subarch=params.subarch,
             release=params.release, label=params.label)
 
         self.assertThat(
 
=== modified file 'src/provisioningserver/boot/tftppath.py'
--- src/provisioningserver/boot/tftppath.py	2014-04-23 16:09:39 +0000
+++ src/provisioningserver/boot/tftppath.py	2014-05-13 18:46:09 +0000
@@ -25,6 +25,7 @@
 from logging import getLogger
 import os.path
 
+from provisioningserver.driver import OperatingSystemRegistry
 
 logger = getLogger(__name__)
 
@@ -114,16 +115,16 @@
 def extract_image_params(path):
     """Represent a list of TFTP path elements as a list of boot-image dicts.
 
-    The path must consist of a full [architecture, subarchitecture, release]
-    that identify a kind of boot that we may need an image for.
+    The path must consist of a full [osystem, architecture, subarchitecture,
+    release] that identify a kind of boot that we may need an image for.
     """
     osystem, arch, subarch, release, label = path
-    # XXX: rvb 2014-03-24: The images import script currently imports all the
-    # images for the configured selections (where a selection is an
-    # arch/subarch/series/label combination).  When the import script grows the
-    # ability to import the images for a particular purpose, we need to change
-    # this code to report what is actually present.
-    purposes = ['commissioning', 'install', 'xinstall']
+    osystem_obj = OperatingSystemRegistry.get_item(osystem, default=None)
+    if osystem_obj is None:
+        return []
+
+    purposes = osystem_obj.get_boot_image_purposes(
+        arch, subarch, release, label)
     return [
         dict(
             osystem=osystem, architecture=arch, subarchitecture=subarch,
 
=== modified file 'src/provisioningserver/driver/__init__.py'
--- src/provisioningserver/driver/__init__.py	2014-03-28 16:46:55 +0000
+++ src/provisioningserver/driver/__init__.py	2014-05-13 18:46:09 +0000
@@ -16,17 +16,30 @@
     "Architecture",
     "ArchitectureRegistry",
     "BootResource",
+    "OperatingSystem",
+    "OperatingSystemRegistry",
     ]
 
 from abc import (
     ABCMeta,
     abstractmethod,
+    abstractproperty,
     )
 
 from provisioningserver.power_schema import JSON_POWER_TYPE_PARAMETERS
 from provisioningserver.utils.registry import Registry
 
 
+class BOOT_IMAGE_PURPOSE:
+    """The vocabulary of a `BootImage`'s purpose."""
+    #: Usable for commissioning
+    COMMISSIONING = 'commissioning'
+    #: Usable for install
+    INSTALL = 'install'
+    #: Usable for fast-path install
+    XINSTALL = 'xinstall'
+
+
 class Architecture:
 
     def __init__(self, name, description, pxealiases=None,
@@ -98,6 +111,54 @@
         """
 
 
+class OperatingSystem:
+    """Skeleton for an operating system."""
+
+    __metaclass__ = ABCMeta
+
+    @abstractproperty
+    def name(self):
+        """Name of the operating system."""
+
+    @abstractproperty
+    def title(self):
+        """Title of the operating system."""
+
+    @abstractmethod
+    def get_supported_releases(self):
+        """Gets list of supported releases for Ubuntu.
+
+        :returns: list of supported releases
+        """
+
+    @abstractmethod
+    def get_default_release(self):
+        """Gets the default release to use when a release is not
+        explicit.
+
+        :returns: default release to use
+        """
+
+    @abstractmethod
+    def format_release_choices(self, releases):
+        """Formats the release choices that are presented to the user.
+
+        :param releases: list of installed boot image releases
+        :returns: Return Django "choices" list
+        """
+
+    @abstractmethod
+    def get_boot_image_purposes(self, arch, subarch, release, label):
+        """Returns the supported purposes of a boot image.
+
+        :param arch: Architecture of boot image.
+        :param subarch: Sub-architecture of boot image.
+        :param release: Release of boot image.
+        :param label: Label of boot image.
+        :returns: list of supported purposes
+        """
+
+
 class HardwareDiscoverContext:
 
     __metaclass__ = ABCMeta
@@ -126,6 +187,10 @@
     """Registry for boot resource classes."""
 
 
+class OperatingSystemRegistry(Registry):
+    """Registry for operating system classes."""
+
+
 class PowerTypeRegistry(Registry):
     """Registry for power type classes."""
 
@@ -147,3 +212,11 @@
 builtin_power_types = JSON_POWER_TYPE_PARAMETERS
 for power_type in builtin_power_types:
     PowerTypeRegistry.register_item(power_type['name'], power_type)
+
+
+from provisioningserver.driver.os_ubuntu import UbuntuOS
+builtin_osystems = [
+    UbuntuOS(),
+    ]
+for osystem in builtin_osystems:
+    OperatingSystemRegistry.register_item(osystem.name, osystem)
 
=== added file 'src/provisioningserver/driver/os_ubuntu.py'
--- src/provisioningserver/driver/os_ubuntu.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/driver/os_ubuntu.py	2014-05-13 18:46:09 +0000
@@ -0,0 +1,89 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Ubuntu Operating System."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "UbuntuOS",
+    ]
+
+from provisioningserver.driver import (
+    BOOT_IMAGE_PURPOSE,
+    OperatingSystem,
+    )
+
+
+DISTRO_SERIES_CHOICES = {
+    'precise': 'Ubuntu 12.04 LTS "Precise Pangolin"',
+    'quantal': 'Ubuntu 12.10 "Quantal Quetzal"',
+    'raring': 'Ubuntu 13.04 "Raring Ringtail"',
+    'saucy': 'Ubuntu 13.10 "Saucy Salamander"',
+    'trusty': 'Ubuntu 14.04 LTS "Trusty Tahr"',
+}
+
+COMMISIONING_DISTRO_SERIES = [
+    'trusty',
+]
+
+DISTRO_SERIES_DEFAULT = 'trusty'
+COMMISIONING_DISTRO_SERIES_DEFAULT = 'trusty'
+
+
+class UbuntuOS(OperatingSystem):
+    """Ubuntu operating system."""
+
+    name = "ubuntu"
+    title = "Ubuntu"
+
+    def get_boot_image_purposes(self, arch, subarch, release, label):
+        """Gets the purpose of each boot image."""
+        return [
+            BOOT_IMAGE_PURPOSE.COMMISSIONING,
+            BOOT_IMAGE_PURPOSE.INSTALL,
+            BOOT_IMAGE_PURPOSE.XINSTALL
+            ]
+
+    def get_supported_releases(self):
+        """Gets list of supported releases for Ubuntu."""
+        # To make this data better, could pull this information from
+        # simplestreams. So only need to update simplestreams for a
+        # new release.
+        return DISTRO_SERIES_CHOICES.keys()
+
+    def get_default_release(self):
+        """Gets the default release to use when a release is not
+        explicit."""
+        return DISTRO_SERIES_DEFAULT
+
+    def get_supported_commissioning_releases(self):
+        """Gets the supported commissioning releases for Ubuntu. This
+        only exists on Ubuntu, because that is the only operating
+        system that supports commissioning.
+        """
+        return COMMISIONING_DISTRO_SERIES
+
+    def get_default_commissioning_release(self):
+        """Gets the default commissioning release for Ubuntu. This only exists
+        on Ubuntu, because that is the only operating system that supports
+        commissioning.
+        """
+        return COMMISIONING_DISTRO_SERIES_DEFAULT
+
+    def format_release_choices(self, releases):
+        """Formats the release choices that are presented to the user."""
+        choices = []
+        releases = sorted(releases, reverse=True)
+        for release in releases:
+            title = DISTRO_SERIES_CHOICES.get(release)
+            if title is not None:
+                choices.append((release, title))
+        return choices
 
=== added file 'src/provisioningserver/driver/tests/test_os_ubuntu.py'
--- src/provisioningserver/driver/tests/test_os_ubuntu.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/driver/tests/test_os_ubuntu.py	2014-05-13 18:46:09 +0000
@@ -0,0 +1,76 @@
+# Copyright 2012-2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for the UbuntuOS module."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = []
+
+from itertools import product
+from maastesting.factory import factory
+from maastesting.testcase import MAASTestCase
+from provisioningserver.driver import BOOT_IMAGE_PURPOSE
+from provisioningserver.driver.os_ubuntu import (
+    COMMISIONING_DISTRO_SERIES,
+    COMMISIONING_DISTRO_SERIES_DEFAULT,
+    DISTRO_SERIES_CHOICES,
+    DISTRO_SERIES_DEFAULT,
+    UbuntuOS,
+    )
+
+
+class TestUbuntuOS(MAASTestCase):
+
+    def test_get_boot_image_purposes(self):
+        osystem = UbuntuOS()
+        archs = [factory.make_name('arch') for _ in range(2)]
+        subarchs = [factory.make_name('subarch') for _ in range(2)]
+        releases = [factory.make_name('release') for _ in range(2)]
+        labels = [factory.make_name('label') for _ in range(2)]
+        for arch, subarch, release, label in product(
+                archs, subarchs, releases, labels):
+            expected = osystem.get_boot_image_purposes(
+                arch, subarchs, release, label)
+            self.assertIsInstance(expected, list)
+            self.assertEqual(expected, [
+                BOOT_IMAGE_PURPOSE.COMMISSIONING,
+                BOOT_IMAGE_PURPOSE.INSTALL,
+                BOOT_IMAGE_PURPOSE.XINSTALL
+                ])
+
+    def test_get_supported_releases(self):
+        osystem = UbuntuOS()
+        expected = osystem.get_supported_releases()
+        self.assertIsInstance(expected, list)
+        self.assertEqual(expected, DISTRO_SERIES_CHOICES.keys())
+
+    def test_get_default_release(self):
+        osystem = UbuntuOS()
+        expected = osystem.get_default_release()
+        self.assertEqual(expected, DISTRO_SERIES_DEFAULT)
+
+    def test_get_supported_commissioning_releases(self):
+        osystem = UbuntuOS()
+        expected = osystem.get_supported_commissioning_releases()
+        self.assertIsInstance(expected, list)
+        self.assertEqual(expected, COMMISIONING_DISTRO_SERIES)
+
+    def test_default_commissioning_release(self):
+        osystem = UbuntuOS()
+        expected = osystem.get_default_commissioning_release()
+        self.assertEqual(expected, COMMISIONING_DISTRO_SERIES_DEFAULT)
+
+    def test_format_release_choices(self):
+        osystem = UbuntuOS()
+        releases = osystem.get_supported_releases()
+        formatted = osystem.format_release_choices(releases)
+        for name, title in formatted:
+            self.assertEqual(DISTRO_SERIES_CHOICES[name], title)
 
=== modified file 'src/provisioningserver/driver/tests/test_registries.py'
--- src/provisioningserver/driver/tests/test_registries.py	2014-03-28 16:46:55 +0000
+++ src/provisioningserver/driver/tests/test_registries.py	2014-05-13 18:46:09 +0000
@@ -20,6 +20,7 @@
     Architecture,
     ArchitectureRegistry,
     BootResourceRegistry,
+    OperatingSystemRegistry,
     PowerTypeRegistry,
     )
 from provisioningserver.utils.testing import RegistryFixture
@@ -68,6 +69,13 @@
         self.assertEqual(
             None, ArchitectureRegistry.get_by_pxealias("stinkywinky"))
 
+    def test_operating_system_registry(self):
+        self.assertItemsEqual([], OperatingSystemRegistry)
+        OperatingSystemRegistry.register_item("resource", sentinel.resource)
+        self.assertIn(
+            sentinel.resource,
+            (item for name, item in OperatingSystemRegistry))
+
     def test_power_type_registry(self):
         self.assertItemsEqual([], PowerTypeRegistry)
         PowerTypeRegistry.register_item("resource", sentinel.resource)
 
=== modified file 'src/provisioningserver/rpc/tests/test_clusterservice.py'
--- src/provisioningserver/rpc/tests/test_clusterservice.py	2014-05-13 18:43:40 +0000
+++ src/provisioningserver/rpc/tests/test_clusterservice.py	2014-05-13 18:46:09 +0000
@@ -34,6 +34,7 @@
     sentinel,
     )
 from provisioningserver.boot import tftppath
+from provisioningserver.boot.tests.test_tftppath import make_osystem
 from provisioningserver.power_schema import JSON_POWER_TYPE_PARAMETERS
 from provisioningserver.rpc import (
     cluster,
@@ -179,6 +180,7 @@
         tftpdir = self.make_dir()
         for options in product(osystems, archs, subarchs, releases, labels):
             os.makedirs(os.path.join(tftpdir, *options))
+            make_osystem(self, options[0], purposes)
 
         # Ensure that list_boot_images() uses the above TFTP file tree.
         self.useFixture(set_tftp_root(tftpdir))