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

[Blake Rouse]

Removed the DISTRO_SERIES enums, allow each operating system to compose its own preseed.

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

Removed the DISTRO_SERIES enums as they are no longer needed, all information comes from the OperatingSystemRegistry.

Added the ability for an operating system to compose its own preseed. This will be used for Windows, CentOS and other operating systems.

=== modified file 'src/maasserver/api.py'
--- src/maasserver/api.py	2014-04-24 14:57:25 +0000
+++ src/maasserver/api.py	2014-04-24 17:04:47 +0000
@@ -246,6 +246,10 @@
 from piston.handler import typemapper
 from piston.utils import rc
 from provisioningserver.kernel_opts import KernelParameters
+from provisioningserver.osystems import (
+    BOOT_IMAGE_PURPOSE,
+    OperatingSystemRegistry,
+    )
 from provisioningserver.power_schema import UNKNOWN_POWER_TYPE
 import simplejson as json
 
@@ -402,8 +406,11 @@
         :param user_data: If present, this blob of user-data to be made
             available to the nodes through the metadata service.
         :type user_data: base64-encoded unicode
+        :param osystem: If present, this parameter specifies the
+            operating system the node will use.
+        :type osystem: unicode
         :param distro_series: If present, this parameter specifies the
-            Ubuntu Release the node will use.
+            os relase the node will use.
         :type distro_series: unicode
 
         Ideally we'd have MIME multipart and content-transfer-encoding etc.
@@ -412,14 +419,25 @@
         encoding instead.
         """
         user_data = request.POST.get('user_data', None)
+        osystem = request.POST.get('os', request.POST.get('osystem', None))
         series = request.POST.get('distro_series', None)
         if user_data is not None:
             user_data = b64decode(user_data)
-        if series is not None:
+
+        if osystem is not None or series is not None:
+            # If series is set and not osystem this means that we
+            # should use the default operating system
+            if osystem is None and series is not None:
+                osystem = Config.objects.get_config('default_osystem')
+            # If osystem is set and not series, then we need to set
+            # the series to be default for the osystem.
+            elif osystem is not None and series is None:
+                series = ''
+
             node = Node.objects.get_node_or_404(
                 system_id=system_id, user=request.user,
                 perm=NODE_PERMISSION.EDIT)
-            node.set_distro_series(series=series)
+            node.set_osystem_and_distro_series(osystem, series)
         nodes = Node.objects.start_nodes(
             [system_id], request.user, user_data=user_data)
         if len(nodes) == 0:
@@ -432,7 +450,7 @@
         """Release a node.  Opposite of `NodesHandler.acquire`."""
         node = Node.objects.get_node_or_404(
             system_id=system_id, user=request.user, perm=NODE_PERMISSION.EDIT)
-        node.set_distro_series(series='')
+        node.set_osystem_and_distro_series(osystem='', series='')
         if node.status == NODE_STATUS.READY:
             # Nothing to do.  This may be a redundant retry, and the
             # postcondition is achieved, so call this success.
@@ -2321,7 +2339,7 @@
         context_instance=RequestContext(request))
 
 
-def get_boot_purpose(node):
+def get_boot_purpose(node, osystem, arch, subarch, series, label):
     """Return a suitable "purpose" for this boot, e.g. "install"."""
     # XXX: allenap bug=1031406 2012-07-31: The boot purpose is still in
     # flux. It may be that there will just be an "ephemeral" environment and
@@ -2341,7 +2359,15 @@
             if node.should_use_traditional_installer():
                 return "install"
             else:
-                return "xinstall"
+                # Check that the booting operating system, actually supports
+                # fast-path installation. If it does not then, we need to
+                # return normal install.
+                osystem_obj = OperatingSystemRegistry[osystem]
+                purposes = osystem_obj.get_boot_image_purposes(
+                    arch, subarch, series, label)
+                if BOOT_IMAGE_PURPOSE.XINSTALL in purposes:
+                    return "xinstall"
+                return "install"
         else:
             return "local"  # TODO: Investigate.
     else:
@@ -2409,12 +2435,12 @@
     node = get_node_from_mac_string(request.GET.get('mac', None))
 
     if node is None or node.status == NODE_STATUS.COMMISSIONING:
+        osystem = Config.objects.get_config('commissioning_osystem')
         series = Config.objects.get_config('commissioning_distro_series')
     else:
+        osystem = node.get_osystem()
         series = node.get_distro_series()
 
-    purpose = get_boot_purpose(node)
-
     if node:
         arch, subarch = node.architecture.split('/')
         preseed_url = compose_preseed_url(node)
@@ -2440,7 +2466,7 @@
                 # current series. If nothing is found, fall back to i386 like
                 # we used to. LP #1181334
                 image = BootImage.objects.get_default_arch_image_in_nodegroup(
-                    nodegroup, series, purpose=purpose)
+                    nodegroup, osystem, series, purpose='commissioning')
                 if image is None:
                     arch = 'i386'
                 else:
@@ -2448,12 +2474,17 @@
 
         subarch = get_optional_param(request.GET, 'subarch', 'generic')
 
+    # Get the purpose, checking that if node is using xinstall, the operating
+    # system actaully supports that mode. We pass None for the label, here
+    # because it is unknown which label will be used yet.
+    purpose = get_boot_purpose(node, osystem, arch, subarch, series, None)
+
     # We use as our default label the label of the most recent image for
     # the criteria we've assembled above. If there is no latest image
     # (which should never happen in reality but may happen in tests), we
     # fall back to using 'no-such-image' as our default.
     latest_image = BootImage.objects.get_latest_image(
-        nodegroup, arch, subarch, series, purpose)
+        nodegroup, osystem, arch, subarch, series, purpose)
     if latest_image is None:
         # XXX 2014-03-18 gmb bug=1294131:
         #     We really ought to raise an exception here so that client
@@ -2465,6 +2496,10 @@
         latest_label = latest_image.label
     label = get_optional_param(request.GET, 'label', latest_label)
 
+    # Now that we have the correct label, lets check the boot purpose again
+    # to make sure that the boot image with that label, is the correct purpose.
+    purpose = get_boot_purpose(node, osystem, arch, subarch, series, label)
+
     if node is not None:
         # We don't care if the kernel opts is from the global setting or a tag,
         # just get the options
@@ -2494,8 +2529,8 @@
     cluster_address = get_mandatory_param(request.GET, "local")
 
     params = KernelParameters(
-        arch=arch, subarch=subarch, release=series, label=label,
-        purpose=purpose, hostname=hostname, domain=domain,
+        osystem=osystem, arch=arch, subarch=subarch, release=series,
+        label=label, purpose=purpose, hostname=hostname, domain=domain,
         preseed_url=preseed_url, log_host=server_address,
         fs_host=cluster_address, extra_opts=extra_kernel_opts)
 
@@ -2536,10 +2571,11 @@
     This function has a counterpart, `summarise_boot_image_dict`.  The two
     return the same value for the same boot image.
 
-    :return: A tuple of the image's architecture, subarchitecture, release,
-        label, and purpose.
+    :return: A tuple of the image's osystem, architecture, subarchitecture,
+        release, label, and purpose.
     """
     return (
+        image_object.osystem,
         image_object.architecture,
         image_object.subarchitecture,
         image_object.release,
@@ -2554,10 +2590,11 @@
     This is the counterpart to `summarise_boot_image_object`.  The two return
     the same value for the same boot image.
 
-    :return: A tuple of the image's architecture, subarchitecture, release,
-        label, and purpose.
+    :return: A tuple of the image's osystem, architecture, subarchitecture,
+        release, label, and purpose.
     """
     return (
+        image_dict['osystem'],
         image_dict['architecture'],
         image_dict.get('subarchitecture', 'generic'),
         image_dict['release'],
@@ -2600,10 +2637,11 @@
         `summarise_stored_images`.
     """
     new_images = reported_images - stored_images
-    for arch, subarch, release, label, purpose in new_images:
+    for osystem, arch, subarch, release, label, purpose in new_images:
         BootImage.objects.register_image(
-            nodegroup=nodegroup, architecture=arch, subarchitecture=subarch,
-            release=release, purpose=purpose, label=label)
+            nodegroup=nodegroup, osystem=osystem, architecture=arch,
+            subarchitecture=subarch, release=release, purpose=purpose,
+            label=label)
 
 
 def prune_boot_images(nodegroup, reported_images, stored_images):
@@ -2620,15 +2658,16 @@
         `summarise_stored_images`.
     """
     removed_images = stored_images - reported_images
-    for arch, subarch, release, label, purpose in removed_images:
+    for osystem, arch, subarch, release, label, purpose in removed_images:
         db_images = BootImage.objects.filter(
-            architecture=arch, subarchitecture=subarch,
+            osystem=osystem, architecture=arch, subarchitecture=subarch,
             release=release, label=label, purpose=purpose)
         db_images.delete()
 
 
 DISPLAYED_BOOTIMAGE_FIELDS = (
     'id',
+    'osystem',
     'release',
     'architecture',
     'subarchitecture',
@@ -2694,10 +2733,10 @@
         :param uuid: The UUID of the cluster for which the images are
             being reported.
         :param images: A list of dicts, each describing a boot image with
-            these properties: `architecture`, `subarchitecture`, `release`,
-            `purpose`, and optionally, `label` (which defaults to "release").
-            These should match the code that determines TFTP paths for these
-            images.
+            these properties: `os`, `architecture`, `subarchitecture`,
+            `release`, `purpose`, and optionally, `label` (which defaults
+            to "release"). These should match the code that determines TFTP
+            paths for these images.
         """
         nodegroup = get_object_or_404(NodeGroup, uuid=uuid)
         check_nodegroup_access(request, nodegroup)

=== modified file 'src/maasserver/compose_preseed.py'
--- src/maasserver/compose_preseed.py	2013-10-18 09:54:17 +0000
+++ src/maasserver/compose_preseed.py	2014-04-24 17:04:47 +0000
@@ -20,6 +20,7 @@
 
 from maasserver.enum import NODE_STATUS
 from maasserver.utils import absolute_reverse
+from provisioningserver.osystems import OperatingSystemRegistry
 import yaml
 
 
@@ -104,6 +105,12 @@
     if node.status == NODE_STATUS.COMMISSIONING:
         return compose_commissioning_preseed(token, base_url)
     else:
+        # Operating system might support a custom preseed generation
+        osystem = OperatingSystemRegistry.get_item(node.get_osystem())
+        if osystem is not None and hasattr(osystem, 'compose_preseed'):
+            metadata_url = absolute_reverse('metadata', base_url=base_url)
+            return osystem.compose_preseed(node, token, metadata_url)
+
         if node.should_use_traditional_installer():
             return compose_cloud_init_preseed(token, base_url)
         else:

=== modified file 'src/maasserver/context_processors.py'
--- src/maasserver/context_processors.py	2014-04-01 06:54:45 +0000
+++ src/maasserver/context_processors.py	2014-04-24 17:04:47 +0000
@@ -63,6 +63,7 @@
             'js/node_views.js',
             'js/longpoll.js',
             'js/enums.js',
+            'js/os_distro_select.js',
             'js/power_parameters.js',
             'js/nodes_chart.js',
             'js/reveal.js',

=== modified file 'src/maasserver/enum.py'
--- src/maasserver/enum.py	2014-03-28 16:36:32 +0000
+++ src/maasserver/enum.py	2014-04-24 17:04:47 +0000
@@ -86,36 +86,6 @@
 NODE_STATUS_CHOICES_DICT = OrderedDict(NODE_STATUS_CHOICES)
 
 
-class DISTRO_SERIES:
-    """List of supported ubuntu releases."""
-    #:
-    default = ''
-    #:
-    precise = 'precise'
-    #:
-    quantal = 'quantal'
-    #:
-    raring = 'raring'
-    #:
-    saucy = 'saucy'
-    #:
-    trusty = 'trusty'
-
-DISTRO_SERIES_CHOICES = (
-    (DISTRO_SERIES.default, 'Default Ubuntu Release'),
-    (DISTRO_SERIES.precise, 'Ubuntu 12.04 LTS "Precise Pangolin"'),
-    (DISTRO_SERIES.quantal, 'Ubuntu 12.10 "Quantal Quetzal"'),
-    (DISTRO_SERIES.raring, 'Ubuntu 13.04 "Raring Ringtail"'),
-    (DISTRO_SERIES.saucy, 'Ubuntu 13.10 "Saucy Salamander"'),
-    (DISTRO_SERIES.trusty, 'Ubuntu 14.04 LTS "Trusty Tahr"'),
-)
-
-
-COMMISSIONING_DISTRO_SERIES_CHOICES = (
-    (DISTRO_SERIES.trusty, dict(DISTRO_SERIES_CHOICES)[DISTRO_SERIES.trusty]),
-)
-
-
 class NODE_PERMISSION:
     """Permissions relating to nodes."""
     VIEW = 'view_node'

=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py	2014-04-22 09:08:02 +0000
+++ src/maasserver/forms.py	2014-04-24 17:04:47 +0000
@@ -71,9 +71,6 @@
     )
 from maasserver.config_forms import SKIP_CHECK_NAME
 from maasserver.enum import (
-    COMMISSIONING_DISTRO_SERIES_CHOICES,
-    DISTRO_SERIES,
-    DISTRO_SERIES_CHOICES,
     NODE_STATUS,
     NODEGROUPINTERFACE_MANAGEMENT,
     NODEGROUPINTERFACE_MANAGEMENT_CHOICES,
@@ -86,7 +83,7 @@
 from maasserver.forms_settings import (
     CONFIG_ITEMS_KEYS,
     get_config_field,
-    INVALID_DISTRO_SERIES_MESSAGE,
+    list_commisioning_choices,
     INVALID_SETTING_MSG_TEMPLATE,
     )
 from maasserver.models import (
@@ -113,6 +110,7 @@
 from maasserver.utils.network import make_network
 from metadataserver.fields import Bin
 from metadataserver.models import CommissioningScript
+from provisioningserver.osystems import OperatingSystemRegistry
 
 # A reusable null-option for choice fields.
 BLANK_CHOICE = ('', '-------')
@@ -202,6 +200,81 @@
         return all_architectures[0]
 
 
+def list_all_usable_osystems():
+    """Return all operating systems that can be used for nodes.
+
+    These are the operating systems for which any nodegroup has the boot images
+    required to boot the node.
+    """
+    # The Node edit form offers all usable operating systems as options for the
+    # osystem field.  Not all of these may be available in the node's
+    # nodegroup, but to represent that accurately in the UI would depend on
+    # the currently selected nodegroup.  Narrowing the options down further
+    # would have to happen browser-side.
+    osystems = set()
+    for nodegroup in NodeGroup.objects.all():
+        osystems = osystems.union(
+            BootImage.objects.get_usable_osystems(nodegroup))
+    osystems = [OperatingSystemRegistry[osystem] for osystem in osystems]
+    return sorted(osystems, key=lambda osystem: osystem.title)
+
+
+def list_osystem_choices(osystems):
+    """Return Django "choices" list for `osystem`."""
+    choices = [('', 'Default OS')]
+    choices += [
+        (osystem.name, osystem.title)
+        for osystem in osystems
+        ]
+    return choices
+
+
+def list_all_usable_releases(osystems):
+    """Return dictionary of usable `releases` for each opertaing system."""
+    distro_series = {}
+    nodegroups = list(NodeGroup.objects.all())
+    for osystem in osystems:
+        releases = set()
+        for nodegroup in nodegroups:
+            releases = releases.union(
+                BootImage.objects.get_usable_releases(nodegroup, osystem.name))
+        distro_series[osystem.name] = sorted(releases)
+    return distro_series
+
+
+def list_release_choices(releases):
+    """Return Django "choices" list for `releases`."""
+    choices = [('', 'Default OS Release')]
+    for key, value in releases.items():
+        osystem = OperatingSystemRegistry[key]
+        options = osystem.format_release_choices(value)
+        choices += [(
+            '%s/' % osystem.name,
+            'Latest %s Release' % osystem.title
+            )]
+        choices += [
+            ('%s/%s' % (osystem.name, name), title)
+            for name, title in options
+            ]
+        choices += options
+    return choices
+
+
+def clean_distro_series_field(form, field, os_field):
+    # distro_series field can be supplied the value os/release, that is the
+    # way the web UI provides the value.
+    new_distro_series = form.cleaned_data.get(field)
+    if new_distro_series is not None and '/' in new_distro_series:
+        os, release = new_distro_series.split('/', 1)
+        if 'os' in form.cleaned_data:
+            new_os = form.cleaned_data[os_field]
+            if os != new_os:
+                raise ValidationError(
+                    "%s option does not match osystem option." % field)
+        return release
+    return new_distro_series
+
+
 class NodeForm(ModelForm):
 
     def __init__(self, request=None, *args, **kwargs):
@@ -214,6 +287,7 @@
             self.fields['nodegroup'] = NodeGroupFormField(
                 required=False, empty_label="Default (master)")
         self.set_up_architecture_field()
+        self.set_up_osystem_and_distro_series_fields()
 
     def set_up_architecture_field(self):
         """Create the `architecture` field.
@@ -233,6 +307,27 @@
             choices=choices, required=True, initial=default_arch,
             error_messages={'invalid_choice': invalid_arch_message})
 
+    def set_up_osystem_and_distro_series_fields(self):
+        """Create the `osystem` and `distro_series` fields.
+
+        This needs to be done on the fly so that we can pass a dynamic list of
+        usable operating systems and distro_series.
+        """
+        osystems = list_all_usable_osystems()
+        releases = list_all_usable_releases(osystems)
+        choices = list_osystem_choices(osystems)
+        distro_choices = list_release_choices(releases)
+        invalid_osystem_message = compose_invalid_choice_text(
+            'osystem', choices)
+        invalid_distro_series_message = compose_invalid_choice_text(
+            'distro_series', distro_choices)
+        self.fields['osystem'] = forms.ChoiceField(
+            choices=choices, required=False, initial='',
+            error_messages={'invalid_choice': invalid_osystem_message})
+        self.fields['distro_series'] = forms.ChoiceField(
+            choices=distro_choices, required=False, initial='',
+            error_messages={'invalid_choice': invalid_distro_series_message})
+
     def clean_hostname(self):
         # Don't allow the hostname to be changed if the node is
         # currently allocated.  Juju knows the node by its old name, so
@@ -246,6 +341,9 @@
 
         return new_hostname
 
+    def clean_distro_series(self):
+        return clean_distro_series_field(self, 'distro_series', 'osystem')
+
     def is_valid(self):
         is_valid = super(NodeForm, self).is_valid()
         if len(list_all_usable_architectures()) == 0:
@@ -254,12 +352,6 @@
             is_valid = False
         return is_valid
 
-    distro_series = forms.ChoiceField(
-        choices=DISTRO_SERIES_CHOICES, required=False,
-        initial=DISTRO_SERIES.default,
-        label="Release",
-        error_messages={'invalid_choice': INVALID_DISTRO_SERIES_MESSAGE})
-
     hostname = forms.CharField(
         label="Host name", required=False, help_text=(
             "The FQDN (Fully Qualified Domain Name) is derived from the "
@@ -277,6 +369,7 @@
         fields = (
             'hostname',
             'architecture',
+            'osystem',
             'distro_series',
             )
 
@@ -858,16 +951,34 @@
     """Settings page, Commissioning section."""
     check_compatibility = get_config_field('check_compatibility')
     commissioning_distro_series = forms.ChoiceField(
-        choices=COMMISSIONING_DISTRO_SERIES_CHOICES, required=False,
-        label="Default distro series used for commissioning",
+        choices=list_commisioning_choices(), required=False,
+        label="Default Ubuntu release used for commissioning",
         error_messages={'invalid_choice': compose_invalid_choice_text(
             'commissioning_distro_series',
-            COMMISSIONING_DISTRO_SERIES_CHOICES)})
+            list_commisioning_choices())})
+
+
+class DeployForm(ConfigForm):
+    """Settings page, Deploy section."""
+    default_osystem = get_config_field('default_osystem')
+    default_distro_series = get_config_field('default_distro_series')
+
+    def _load_initials(self):
+        super(DeployForm, self)._load_initials()
+        initial_os = self.initial['default_osystem']
+        initial_series = self.initial['default_distro_series']
+        self.initial['default_distro_series'] = '%s/%s' % (
+            initial_os,
+            initial_series
+            )
+
+    def clean_default_distro_series(self):
+        return clean_distro_series_field(
+            self, 'default_distro_series', 'default_osystem')
 
 
 class UbuntuForm(ConfigForm):
     """Settings page, Ubuntu section."""
-    default_distro_series = get_config_field('default_distro_series')
     main_archive = get_config_field('main_archive')
     ports_archive = get_config_field('ports_archive')
 

=== modified file 'src/maasserver/forms_settings.py'
--- src/maasserver/forms_settings.py	2014-04-10 20:21:24 +0000
+++ src/maasserver/forms_settings.py	2014-04-24 17:04:47 +0000
@@ -23,19 +23,39 @@
 from socket import gethostname
 
 from django import forms
-from maasserver.enum import (
-    COMMISSIONING_DISTRO_SERIES_CHOICES,
-    DISTRO_SERIES,
-    DISTRO_SERIES_CHOICES,
-    )
+from maasserver.models.config import DEFAULT_OS
 from maasserver.utils.forms import compose_invalid_choice_text
+from provisioningserver.osystems import OperatingSystemRegistry
 
 
 INVALID_URL_MESSAGE = "Enter a valid url (e.g. http://host.example.com)."
 
 
-INVALID_DISTRO_SERIES_MESSAGE = compose_invalid_choice_text(
-    'distro_series', DISTRO_SERIES_CHOICES)
+def list_osystem_choices():
+    return [
+        (osystem.name, osystem.title)
+        for _, osystem in OperatingSystemRegistry
+        ]
+
+
+def list_release_choices():
+    osystems = [osystem for _, osystem in OperatingSystemRegistry]
+    choices = []
+    for osystem in osystems:
+        supported = sorted(osystem.get_supported_releases())
+        options = osystem.format_release_choices(supported)
+        options = [
+            ('%s/%s' % (osystem.name, name), title)
+            for name, title in options
+            ]
+        choices += options
+    return choices
+
+
+def list_commisioning_choices():
+    releases = DEFAULT_OS.get_supported_commissioning_releases()
+    options = DEFAULT_OS.format_release_choices(releases)
+    return [(name, title) for name, title in options]
 
 
 CONFIG_ITEMS = {
@@ -139,28 +159,46 @@
                 "e.g. for ntp.ubuntu.com: '91.189.94.4'")
         }
     },
+    'default_osystem': {
+        'default': DEFAULT_OS.name,
+        'form': forms.ChoiceField,
+        'form_kwargs': {
+            'label': "Default operating system used for deployment",
+            'choices': list_osystem_choices(),
+            'required': False,
+            'error_messages': {
+                'invalid_choice': compose_invalid_choice_text(
+                    'osystem',
+                    list_osystem_choices())},
+        }
+    },
     'default_distro_series': {
-        'default': DISTRO_SERIES.trusty,
+        'default': '%s/%s' % (
+            DEFAULT_OS.name,
+            DEFAULT_OS.get_default_release()
+            ),
         'form': forms.ChoiceField,
         'form_kwargs': {
-            'label': "Default distro series used for deployment",
-            'choices': DISTRO_SERIES_CHOICES,
+            'label': "Default OS release used for deployment",
+            'choices': list_release_choices(),
             'required': False,
             'error_messages': {
-                'invalid_choice': INVALID_DISTRO_SERIES_MESSAGE},
+                'invalid_choice': compose_invalid_choice_text(
+                    'distro_series',
+                    list_release_choices())},
         }
     },
     'commissioning_distro_series': {
-        'default': DISTRO_SERIES.trusty,
+        'default': DEFAULT_OS.get_default_commissioning_release(),
         'form': forms.ChoiceField,
         'form_kwargs': {
-            'label': "Default distro series used for commissioning",
-            'choices': COMMISSIONING_DISTRO_SERIES_CHOICES,
+            'label': "Default Ubuntu release used for commissioning",
+            'choices': list_commisioning_choices(),
             'required': False,
             'error_messages': {
                 'invalid_choice': compose_invalid_choice_text(
                     'commissioning_distro_series',
-                    COMMISSIONING_DISTRO_SERIES_CHOICES)},
+                    list_commisioning_choices())},
         }
     },
     'enable_third_party_drivers': {

=== added file 'src/maasserver/migrations/0075_add_osystem_to_bootimage.py'
--- src/maasserver/migrations/0075_add_osystem_to_bootimage.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/0075_add_osystem_to_bootimage.py	2014-04-24 17:04:47 +0000
@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Removing unique constraint on 'BootImage', fields ['subarchitecture', 'label', 'architecture', 'release', 'nodegroup', 'purpose']
+        db.delete_unique(u'maasserver_bootimage', ['subarchitecture', 'label', 'architecture', 'release', 'nodegroup_id', 'purpose'])
+
+        # Adding field 'BootImage.osystem'
+        db.add_column(u'maasserver_bootimage', 'osystem',
+                      self.gf('django.db.models.fields.CharField')(default='ubuntu', max_length=255),
+                      keep_default=False)
+
+        # Adding unique constraint on 'BootImage', fields ['subarchitecture', 'osystem', 'label', 'architecture', 'release', 'nodegroup', 'purpose']
+        db.create_unique(u'maasserver_bootimage', ['subarchitecture', 'osystem', 'label', 'architecture', 'release', 'nodegroup_id', 'purpose'])
+
+
+    def backwards(self, orm):
+        # Removing unique constraint on 'BootImage', fields ['subarchitecture', 'osystem', 'label', 'architecture', 'release', 'nodegroup', 'purpose']
+        db.delete_unique(u'maasserver_bootimage', ['subarchitecture', 'osystem', 'label', 'architecture', 'release', 'nodegroup_id', 'purpose'])
+
+        # Deleting field 'BootImage.osystem'
+        db.delete_column(u'maasserver_bootimage', 'osystem')
+
+        # Adding unique constraint on 'BootImage', fields ['subarchitecture', 'label', 'architecture', 'release', 'nodegroup', 'purpose']
+        db.create_unique(u'maasserver_bootimage', ['subarchitecture', 'label', 'architecture', 'release', 'nodegroup_id', 'purpose'])
+
+
+    models = {
+        u'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        u'auth.permission': {
+            'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        u'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'unique': 'True', 'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Group']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Permission']"}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        u'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        u'maasserver.bootimage': {
+            'Meta': {'unique_together': "((u'nodegroup', u'osystem', u'architecture', u'subarchitecture', u'release', u'purpose', u'label'),)", 'object_name': 'BootImage'},
+            'architecture': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'label': ('django.db.models.fields.CharField', [], {'default': "u'release'", 'max_length': '255'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"}),
+            'osystem': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'purpose': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'release': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'subarchitecture': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.componenterror': {
+            'Meta': {'object_name': 'ComponentError'},
+            'component': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '40'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'error': ('django.db.models.fields.CharField', [], {'max_length': '1000'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.config': {
+            'Meta': {'object_name': 'Config'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'value': ('maasserver.fields.JSONObjectField', [], {'null': 'True'})
+        },
+        u'maasserver.dhcplease': {
+            'Meta': {'object_name': 'DHCPLease'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.IPAddressField', [], {'unique': 'True', 'max_length': '15'}),
+            'mac': ('maasserver.fields.MACAddressField', [], {}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"})
+        },
+        u'maasserver.downloadprogress': {
+            'Meta': {'object_name': 'DownloadProgress'},
+            'bytes_downloaded': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'error': ('django.db.models.fields.CharField', [], {'max_length': '1000', 'blank': 'True'}),
+            'filename': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"}),
+            'size': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.filestorage': {
+            'Meta': {'unique_together': "((u'filename', u'owner'),)", 'object_name': 'FileStorage'},
+            'content': ('metadataserver.fields.BinaryField', [], {'blank': 'True'}),
+            'filename': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.CharField', [], {'default': "u'26215e0a-cafa-11e3-8554-bcee7b78dc5b'", 'unique': 'True', 'max_length': '36'}),
+            'owner': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'})
+        },
+        u'maasserver.macaddress': {
+            'Meta': {'object_name': 'MACAddress'},
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'mac_address': ('maasserver.fields.MACAddressField', [], {'unique': 'True'}),
+            'networks': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['maasserver.Network']", 'symmetrical': 'False', 'blank': 'True'}),
+            'node': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.Node']"}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.network': {
+            'Meta': {'object_name': 'Network'},
+            'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'unique': 'True', 'max_length': '39'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
+            'netmask': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'vlan_tag': ('django.db.models.fields.PositiveSmallIntegerField', [], {'unique': 'True', 'null': 'True', 'blank': 'True'})
+        },
+        u'maasserver.node': {
+            'Meta': {'object_name': 'Node'},
+            'agent_name': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'null': 'True', 'blank': 'True'}),
+            'architecture': ('django.db.models.fields.CharField', [], {'max_length': '31'}),
+            'cpu_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'distro_series': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '20', 'null': 'True', 'blank': 'True'}),
+            'error': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            'hostname': ('django.db.models.fields.CharField', [], {'default': "u''", 'unique': 'True', 'max_length': '255', 'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'memory': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'netboot': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']", 'null': 'True'}),
+            'owner': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'}),
+            'power_parameters': ('maasserver.fields.JSONObjectField', [], {'default': "u''", 'blank': 'True'}),
+            'power_type': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '10', 'blank': 'True'}),
+            'routers': ('djorm_pgarray.fields.ArrayField', [], {'default': 'None', 'dbtype': "u'macaddr'", 'null': 'True', 'blank': 'True'}),
+            'status': ('django.db.models.fields.IntegerField', [], {'default': '0', 'max_length': '10'}),
+            'storage': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'system_id': ('django.db.models.fields.CharField', [], {'default': "u'node-26226a84-cafa-11e3-8554-bcee7b78dc5b'", 'unique': 'True', 'max_length': '41'}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['maasserver.Tag']", 'symmetrical': 'False'}),
+            'token': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['piston.Token']", 'null': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'zone': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.Zone']", 'on_delete': 'models.SET_DEFAULT'})
+        },
+        u'maasserver.nodegroup': {
+            'Meta': {'object_name': 'NodeGroup'},
+            'api_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '18'}),
+            'api_token': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['piston.Token']", 'unique': 'True'}),
+            'cluster_name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100', 'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'dhcp_key': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'maas_url': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '80', 'blank': 'True'}),
+            'status': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'uuid': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '36'})
+        },
+        u'maasserver.nodegroupinterface': {
+            'Meta': {'unique_together': "((u'nodegroup', u'interface'),)", 'object_name': 'NodeGroupInterface'},
+            'broadcast_ip': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'foreign_dhcp_ip': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'interface': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'ip_range_high': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'ip_range_low': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'management': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"}),
+            'router_ip': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'subnet_mask': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.sshkey': {
+            'Meta': {'unique_together': "((u'user', u'key'),)", 'object_name': 'SSHKey'},
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.TextField', [], {}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"})
+        },
+        u'maasserver.tag': {
+            'Meta': {'object_name': 'Tag'},
+            'comment': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'definition': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'kernel_opts': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '256'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.userprofile': {
+            'Meta': {'object_name': 'UserProfile'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'user': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['auth.User']", 'unique': 'True'})
+        },
+        u'maasserver.zone': {
+            'Meta': {'ordering': "[u'name']", 'object_name': 'Zone'},
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '256'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'piston.consumer': {
+            'Meta': {'object_name': 'Consumer'},
+            'description': ('django.db.models.fields.TextField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.CharField', [], {'max_length': '18'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'secret': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'pending'", 'max_length': '16'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'consumers'", 'null': 'True', 'to': u"orm['auth.User']"})
+        },
+        u'piston.token': {
+            'Meta': {'object_name': 'Token'},
+            'callback': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
+            'callback_confirmed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'consumer': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['piston.Consumer']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_approved': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'key': ('django.db.models.fields.CharField', [], {'max_length': '18'}),
+            'secret': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'timestamp': ('django.db.models.fields.IntegerField', [], {'default': '1398266138L'}),
+            'token_type': ('django.db.models.fields.IntegerField', [], {}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'tokens'", 'null': 'True', 'to': u"orm['auth.User']"}),
+            'verifier': ('django.db.models.fields.CharField', [], {'max_length': '10'})
+        }
+    }
+
+    complete_apps = ['maasserver']
\ No newline at end of file

=== added file 'src/maasserver/migrations/0076_add_osystem_to_node.py'
--- src/maasserver/migrations/0076_add_osystem_to_node.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/0076_add_osystem_to_node.py	2014-04-24 17:04:47 +0000
@@ -0,0 +1,243 @@
+# -*- coding: utf-8 -*-
+from south.utils import datetime_utils as datetime
+from south.db import db
+from south.v2 import SchemaMigration
+from django.db import models
+
+
+class Migration(SchemaMigration):
+
+    def forwards(self, orm):
+        # Adding field 'Node.osystem'
+        db.add_column(u'maasserver_node', 'osystem',
+                      self.gf('django.db.models.fields.CharField')(default=u'', max_length=20, null=True, blank=True),
+                      keep_default=False)
+
+
+    def backwards(self, orm):
+        # Deleting field 'Node.osystem'
+        db.delete_column(u'maasserver_node', 'osystem')
+
+
+    models = {
+        u'auth.group': {
+            'Meta': {'object_name': 'Group'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '80'}),
+            'permissions': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['auth.Permission']", 'symmetrical': 'False', 'blank': 'True'})
+        },
+        u'auth.permission': {
+            'Meta': {'ordering': "(u'content_type__app_label', u'content_type__model', u'codename')", 'unique_together': "((u'content_type', u'codename'),)", 'object_name': 'Permission'},
+            'codename': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'content_type': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['contenttypes.ContentType']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '50'})
+        },
+        u'auth.user': {
+            'Meta': {'object_name': 'User'},
+            'date_joined': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'email': ('django.db.models.fields.EmailField', [], {'unique': 'True', 'max_length': '75', 'blank': 'True'}),
+            'first_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'groups': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Group']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_active': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'is_staff': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'is_superuser': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'last_login': ('django.db.models.fields.DateTimeField', [], {'default': 'datetime.datetime.now'}),
+            'last_name': ('django.db.models.fields.CharField', [], {'max_length': '30', 'blank': 'True'}),
+            'password': ('django.db.models.fields.CharField', [], {'max_length': '128'}),
+            'user_permissions': ('django.db.models.fields.related.ManyToManyField', [], {'symmetrical': 'False', 'related_name': "u'user_set'", 'blank': 'True', 'to': u"orm['auth.Permission']"}),
+            'username': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '30'})
+        },
+        u'contenttypes.contenttype': {
+            'Meta': {'ordering': "('name',)", 'unique_together': "(('app_label', 'model'),)", 'object_name': 'ContentType', 'db_table': "'django_content_type'"},
+            'app_label': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'model': ('django.db.models.fields.CharField', [], {'max_length': '100'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '100'})
+        },
+        u'maasserver.bootimage': {
+            'Meta': {'unique_together': "((u'nodegroup', u'osystem', u'architecture', u'subarchitecture', u'release', u'purpose', u'label'),)", 'object_name': 'BootImage'},
+            'architecture': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'label': ('django.db.models.fields.CharField', [], {'default': "u'release'", 'max_length': '255'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"}),
+            'osystem': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'purpose': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'release': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'subarchitecture': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.componenterror': {
+            'Meta': {'object_name': 'ComponentError'},
+            'component': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '40'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'error': ('django.db.models.fields.CharField', [], {'max_length': '1000'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.config': {
+            'Meta': {'object_name': 'Config'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'value': ('maasserver.fields.JSONObjectField', [], {'null': 'True'})
+        },
+        u'maasserver.dhcplease': {
+            'Meta': {'object_name': 'DHCPLease'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.IPAddressField', [], {'unique': 'True', 'max_length': '15'}),
+            'mac': ('maasserver.fields.MACAddressField', [], {}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"})
+        },
+        u'maasserver.downloadprogress': {
+            'Meta': {'object_name': 'DownloadProgress'},
+            'bytes_downloaded': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'error': ('django.db.models.fields.CharField', [], {'max_length': '1000', 'blank': 'True'}),
+            'filename': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"}),
+            'size': ('django.db.models.fields.IntegerField', [], {'null': 'True', 'blank': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.filestorage': {
+            'Meta': {'unique_together': "((u'filename', u'owner'),)", 'object_name': 'FileStorage'},
+            'content': ('metadataserver.fields.BinaryField', [], {'blank': 'True'}),
+            'filename': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.CharField', [], {'default': "u'9bbf01e4-cbbd-11e3-afb3-bcee7b78dc5b'", 'unique': 'True', 'max_length': '36'}),
+            'owner': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'})
+        },
+        u'maasserver.macaddress': {
+            'Meta': {'object_name': 'MACAddress'},
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'mac_address': ('maasserver.fields.MACAddressField', [], {'unique': 'True'}),
+            'networks': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['maasserver.Network']", 'symmetrical': 'False', 'blank': 'True'}),
+            'node': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.Node']"}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.network': {
+            'Meta': {'object_name': 'Network'},
+            'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'unique': 'True', 'max_length': '39'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '255'}),
+            'netmask': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'vlan_tag': ('django.db.models.fields.PositiveSmallIntegerField', [], {'unique': 'True', 'null': 'True', 'blank': 'True'})
+        },
+        u'maasserver.node': {
+            'Meta': {'object_name': 'Node'},
+            'agent_name': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'null': 'True', 'blank': 'True'}),
+            'architecture': ('django.db.models.fields.CharField', [], {'max_length': '31'}),
+            'cpu_count': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'distro_series': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '20', 'null': 'True', 'blank': 'True'}),
+            'error': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            'hostname': ('django.db.models.fields.CharField', [], {'default': "u''", 'unique': 'True', 'max_length': '255', 'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'memory': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'netboot': ('django.db.models.fields.BooleanField', [], {'default': 'True'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']", 'null': 'True'}),
+            'osystem': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '20', 'null': 'True', 'blank': 'True'}),
+            'owner': ('django.db.models.fields.related.ForeignKey', [], {'default': 'None', 'to': u"orm['auth.User']", 'null': 'True', 'blank': 'True'}),
+            'power_parameters': ('maasserver.fields.JSONObjectField', [], {'default': "u''", 'blank': 'True'}),
+            'power_type': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '10', 'blank': 'True'}),
+            'routers': ('djorm_pgarray.fields.ArrayField', [], {'default': 'None', 'dbtype': "u'macaddr'", 'null': 'True', 'blank': 'True'}),
+            'status': ('django.db.models.fields.IntegerField', [], {'default': '0', 'max_length': '10'}),
+            'storage': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'system_id': ('django.db.models.fields.CharField', [], {'default': "u'node-9bbde11a-cbbd-11e3-afb3-bcee7b78dc5b'", 'unique': 'True', 'max_length': '41'}),
+            'tags': ('django.db.models.fields.related.ManyToManyField', [], {'to': u"orm['maasserver.Tag']", 'symmetrical': 'False'}),
+            'token': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['piston.Token']", 'null': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'zone': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.Zone']", 'on_delete': 'models.SET_DEFAULT'})
+        },
+        u'maasserver.nodegroup': {
+            'Meta': {'object_name': 'NodeGroup'},
+            'api_key': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '18'}),
+            'api_token': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['piston.Token']", 'unique': 'True'}),
+            'cluster_name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '100', 'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'dhcp_key': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'maas_url': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '80', 'blank': 'True'}),
+            'status': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'uuid': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '36'})
+        },
+        u'maasserver.nodegroupinterface': {
+            'Meta': {'unique_together': "((u'nodegroup', u'interface'),)", 'object_name': 'NodeGroupInterface'},
+            'broadcast_ip': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'foreign_dhcp_ip': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'interface': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '255', 'blank': 'True'}),
+            'ip': ('django.db.models.fields.GenericIPAddressField', [], {'max_length': '39'}),
+            'ip_range_high': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'ip_range_low': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'management': ('django.db.models.fields.IntegerField', [], {'default': '0'}),
+            'nodegroup': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']"}),
+            'router_ip': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'subnet_mask': ('django.db.models.fields.GenericIPAddressField', [], {'default': 'None', 'max_length': '39', 'null': 'True', 'blank': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.sshkey': {
+            'Meta': {'unique_together': "((u'user', u'key'),)", 'object_name': 'SSHKey'},
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.TextField', [], {}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['auth.User']"})
+        },
+        u'maasserver.tag': {
+            'Meta': {'object_name': 'Tag'},
+            'comment': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'definition': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'kernel_opts': ('django.db.models.fields.TextField', [], {'null': 'True', 'blank': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '256'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'maasserver.userprofile': {
+            'Meta': {'object_name': 'UserProfile'},
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'user': ('django.db.models.fields.related.OneToOneField', [], {'to': u"orm['auth.User']", 'unique': 'True'})
+        },
+        u'maasserver.zone': {
+            'Meta': {'ordering': "[u'name']", 'object_name': 'Zone'},
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            'description': ('django.db.models.fields.TextField', [], {'blank': 'True'}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'name': ('django.db.models.fields.CharField', [], {'unique': 'True', 'max_length': '256'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {})
+        },
+        u'piston.consumer': {
+            'Meta': {'object_name': 'Consumer'},
+            'description': ('django.db.models.fields.TextField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'key': ('django.db.models.fields.CharField', [], {'max_length': '18'}),
+            'name': ('django.db.models.fields.CharField', [], {'max_length': '255'}),
+            'secret': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'status': ('django.db.models.fields.CharField', [], {'default': "'pending'", 'max_length': '16'}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'consumers'", 'null': 'True', 'to': u"orm['auth.User']"})
+        },
+        u'piston.token': {
+            'Meta': {'object_name': 'Token'},
+            'callback': ('django.db.models.fields.CharField', [], {'max_length': '255', 'null': 'True', 'blank': 'True'}),
+            'callback_confirmed': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'consumer': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['piston.Consumer']"}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'is_approved': ('django.db.models.fields.BooleanField', [], {'default': 'False'}),
+            'key': ('django.db.models.fields.CharField', [], {'max_length': '18'}),
+            'secret': ('django.db.models.fields.CharField', [], {'max_length': '32'}),
+            'timestamp': ('django.db.models.fields.IntegerField', [], {'default': '1398350097L'}),
+            'token_type': ('django.db.models.fields.IntegerField', [], {}),
+            'user': ('django.db.models.fields.related.ForeignKey', [], {'blank': 'True', 'related_name': "'tokens'", 'null': 'True', 'to': u"orm['auth.User']"}),
+            'verifier': ('django.db.models.fields.CharField', [], {'max_length': '10'})
+        }
+    }
+
+    complete_apps = ['maasserver']
\ No newline at end of file

=== modified file 'src/maasserver/models/bootimage.py'
--- src/maasserver/models/bootimage.py	2014-03-26 16:01:34 +0000
+++ src/maasserver/models/bootimage.py	2014-04-24 17:04:47 +0000
@@ -34,44 +34,47 @@
     Don't import or instantiate this directly; access as `BootImage.objects`.
     """
 
-    def get_by_natural_key(self, nodegroup, architecture, subarchitecture,
-                           release, purpose, label):
+    def get_by_natural_key(self, nodegroup, osystem, architecture,
+                           subarchitecture, release, purpose, label):
         """Look up a specific image."""
         return self.get(
-            nodegroup=nodegroup, architecture=architecture,
+            nodegroup=nodegroup, osystem=osystem, architecture=architecture,
             subarchitecture=subarchitecture, release=release,
             purpose=purpose, label=label)
 
-    def register_image(self, nodegroup, architecture, subarchitecture,
+    def register_image(self, nodegroup, osystem, architecture, subarchitecture,
                        release, purpose, label):
         """Register an image if it wasn't already registered."""
         self.get_or_create(
-            nodegroup=nodegroup, architecture=architecture,
+            nodegroup=nodegroup, osystem=osystem, architecture=architecture,
             subarchitecture=subarchitecture, release=release,
             purpose=purpose, label=label)
 
-    def have_image(self, nodegroup, architecture, subarchitecture, release,
-                   purpose, label=None):
+    def have_image(self, nodegroup, osystem, architecture, subarchitecture,
+                   release, purpose, label=None):
         """Is an image for the given kind of boot available?"""
         if label is None:
             label = "release"
         try:
             self.get_by_natural_key(
-                nodegroup=nodegroup, architecture=architecture,
-                subarchitecture=subarchitecture, release=release,
-                purpose=purpose, label=label)
+                nodegroup=nodegroup, osystem=osystem,
+                architecture=architecture, subarchitecture=subarchitecture,
+                release=release, purpose=purpose, label=label)
             return True
         except BootImage.DoesNotExist:
             return False
 
-    def get_default_arch_image_in_nodegroup(self, nodegroup, series, purpose):
-        """Return any image for the given nodegroup, series, and purpose.
+    def get_default_arch_image_in_nodegroup(self, nodegroup, osystem, series,
+                                            purpose):
+        """Return any image for the given nodegroup, osystem, series,
+        and purpose.
 
         Prefers `i386` images if available.  Returns `None` if no images match
         requirements.
         """
         images = BootImage.objects.filter(
-            release=series, nodegroup=nodegroup, purpose=purpose)
+            osystem=osystem, release=series, nodegroup=nodegroup,
+            purpose=purpose)
         for image in images:
             # Prefer i386, any available subarchitecture (usually just
             # "generic").  It will work for most cases where we don't know
@@ -106,14 +109,28 @@
             nodegroup, 'install')
         return arches_commissioning & arches_install
 
-    def get_latest_image(self, nodegroup, architecture, subarchitecture,
-                         release, purpose):
+    def get_latest_image(self, nodegroup, osystem, architecture,
+                         subarchitecture, release, purpose):
         """Return the latest image for a set of criteria."""
         return BootImage.objects.filter(
-            nodegroup=nodegroup, architecture=architecture,
+            nodegroup=nodegroup, osystem=osystem, architecture=architecture,
             subarchitecture=subarchitecture, release=release,
             purpose=purpose).order_by('id').last()
 
+    def get_usable_osystems(self, nodegroup):
+        """Return the list of usable operating systems for a nodegroup.
+        """
+        query = BootImage.objects.filter(nodegroup=nodegroup)
+        return set(query.values_list('osystem', flat=True))
+
+    def get_usable_releases(self, nodegroup, osystem):
+        """Return the list of usable releases for a nodegroup and
+        operating system.
+        """
+        query = BootImage.objects.filter(nodegroup=nodegroup, osystem=osystem)
+        releases = query.values_list('release', flat=True)
+        return set(releases)
+
 
 class BootImage(TimestampedModel):
     """Available boot image (i.e. kernel and initrd).
@@ -131,8 +148,8 @@
 
     class Meta(DefaultMeta):
         unique_together = (
-            ('nodegroup', 'architecture', 'subarchitecture', 'release',
-             'purpose', 'label'),
+            ('nodegroup', 'osystem', 'architecture', 'subarchitecture',
+             'release', 'purpose', 'label'),
             )
 
     objects = BootImageManager()
@@ -140,6 +157,9 @@
     # Nodegroup (cluster controller) that has the images.
     nodegroup = ForeignKey(NodeGroup, null=False, editable=False, unique=False)
 
+    # Operating system (e.g. "ubuntu") that the image boots.
+    osystem = CharField(max_length=255, blank=False, editable=False)
+
     # System architecture (e.g. "i386") that the image is for.
     architecture = CharField(max_length=255, blank=False, editable=False)
 
@@ -148,7 +168,7 @@
     # such as i386 and amd64, we use "generic").
     subarchitecture = CharField(max_length=255, blank=False, editable=False)
 
-    # Ubuntu release (e.g. "precise") that the image boots.
+    # OS release (e.g. "precise") that the image boots.
     release = CharField(max_length=255, blank=False, editable=False)
 
     # Boot purpose (e.g. "commissioning" or "install") that the image is for.
@@ -159,7 +179,8 @@
         max_length=255, blank=False, editable=False, default="release")
 
     def __repr__(self):
-        return "<BootImage %s/%s-%s-%s-%s>" % (
+        return "<BootImage %s-%s/%s-%s-%s-%s>" % (
+            self.osystem,
             self.architecture,
             self.subarchitecture,
             self.release,

=== modified file 'src/maasserver/models/config.py'
--- src/maasserver/models/config.py	2014-04-14 21:42:00 +0000
+++ src/maasserver/models/config.py	2014-04-24 17:04:47 +0000
@@ -28,8 +28,11 @@
     )
 from django.db.models.signals import post_save
 from maasserver import DefaultMeta
-from maasserver.enum import DISTRO_SERIES
 from maasserver.fields import JSONObjectField
+from provisioningserver.osystems.ubuntu import UbuntuOS
+
+
+DEFAULT_OS = UbuntuOS()
 
 
 def get_default_config():
@@ -40,11 +43,14 @@
         # Ubuntu section configuration.
         'main_archive': 'http://archive.ubuntu.com/ubuntu',
         'ports_archive': 'http://ports.ubuntu.com/ubuntu-ports',
-        'commissioning_distro_series': DISTRO_SERIES.trusty,
+        'commissioning_osystem': DEFAULT_OS.name,
+        'commissioning_distro_series':
+        DEFAULT_OS.get_default_commissioning_release(),
         # Network section configuration.
         'maas_name': gethostname(),
         'enlistment_domain': b'local',
-        'default_distro_series': DISTRO_SERIES.trusty,
+        'default_osystem': DEFAULT_OS.name,
+        'default_distro_series': DEFAULT_OS.get_default_release(),
         'http_proxy': None,
         'upstream_dns': None,
         'ntp_server': '91.189.94.4',  # ntp.ubuntu.com

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2014-04-21 11:09:09 +0000
+++ src/maasserver/models/node.py	2014-04-24 17:04:47 +0000
@@ -49,8 +49,6 @@
     logger,
     )
 from maasserver.enum import (
-    DISTRO_SERIES,
-    DISTRO_SERIES_CHOICES,
     NODE_PERMISSION,
     NODE_STATUS,
     NODE_STATUS_CHOICES,
@@ -72,6 +70,7 @@
     strip_domain,
     )
 from piston.models import Token
+from provisioningserver.osystems import OperatingSystemRegistry
 from provisioningserver.tasks import (
     power_off,
     power_on,
@@ -190,6 +189,33 @@
                 "Name contains disallowed characters: %r." % label)
 
 
+def validate_osystem(name):
+    """Validator for operating system.
+
+    :raise ValidationError: If invalid operating system selected.
+    """
+    if name is not None and name != '':
+        osystem = OperatingSystemRegistry.get_item(name)
+        if osystem is None:
+            raise ValidationError(
+                "Value u'%s' is not a valid choice." % name)
+
+
+def validate_distro_series(name):
+    """Validator for distro_series.
+
+    :raise ValidationError: If invalid distro series selected.
+    """
+    if name is None or name == '':
+        return
+    releases = set()
+    for _, obj in OperatingSystemRegistry:
+        releases = releases.union(obj.get_supported_releases())
+    if name not in releases:
+        raise ValidationError(
+            "Value u'%s' is not a valid choice." % name)
+
+
 class NodeManager(Manager):
     """A utility to manage the collection of Nodes."""
 
@@ -477,9 +503,13 @@
     owner = ForeignKey(
         User, default=None, blank=True, null=True, editable=False)
 
+    osystem = CharField(
+        max_length=20, null=True, blank=True, default='',
+        validators=[validate_osystem])
+
     distro_series = CharField(
-        max_length=20, choices=DISTRO_SERIES_CHOICES, null=True,
-        blank=True, default='')
+        max_length=20, null=True, blank=True, default='',
+        validators=[validate_distro_series])
 
     architecture = CharField(max_length=31, blank=False)
 
@@ -774,21 +804,48 @@
         """The name of the queue for tasks specific to this node."""
         return self.nodegroup.work_queue
 
+    def get_osystem(self):
+        """Return the operating system to install that node."""
+        use_default_osystem = (
+            not self.osystem or
+            self.osystem == '')
+        if use_default_osystem:
+            return Config.objects.get_config('default_osystem')
+        else:
+            return self.osystem
+
     def get_distro_series(self):
         """Return the distro series to install that node."""
+        use_default_osystem = (
+            not self.osystem or
+            self.osystem == '')
         use_default_distro_series = (
             not self.distro_series or
-            self.distro_series == DISTRO_SERIES.default)
-        if use_default_distro_series:
+            self.distro_series == '')
+        if use_default_osystem and use_default_distro_series:
             return Config.objects.get_config('default_distro_series')
+        elif use_default_distro_series:
+            osystem = OperatingSystemRegistry[self.osystem]
+            return osystem.get_default_release()
         else:
             return self.distro_series
 
+    def set_osystem(self, osystem=''):
+        """Set the operating system to install that node."""
+        self.osystem = osystem
+        self.save()
+
     def set_distro_series(self, series=''):
         """Set the distro series to install that node."""
         self.distro_series = series
         self.save()
 
+    def set_osystem_and_distro_series(self, osystem='', series=''):
+        """Set the oeprating system to install that node."""
+        self.osystem = osystem
+        self.distro_series = series
+        self.save()
+
     def get_effective_power_parameters(self):
         """Return effective power parameters, including any defaults."""
         if self.power_parameters:

=== modified file 'src/maasserver/models/tests/test_bootimage.py'
--- src/maasserver/models/tests/test_bootimage.py	2014-03-18 14:39:11 +0000
+++ src/maasserver/models/tests/test_bootimage.py	2014-04-24 17:04:47 +0000
@@ -50,69 +50,79 @@
         self.assertTrue(BootImage.objects.have_image(nodegroup, **params))
 
     def test_default_arch_image_returns_None_if_no_images_match(self):
+        osystem = Config.objects.get_config('commissioning_osystem')
         series = Config.objects.get_config('commissioning_distro_series')
         result = BootImage.objects.get_default_arch_image_in_nodegroup(
-            factory.make_node_group(), series, factory.make_name('purpose'))
+            factory.make_node_group(), osystem, series,
+            factory.make_name('purpose'))
         self.assertIsNone(result)
 
     def test_default_arch_image_returns_only_matching_image(self):
         nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
         series = factory.make_name('series')
         label = factory.make_name('label')
         arch = factory.make_name('arch')
         purpose = factory.make_name("purpose")
         factory.make_boot_image(
-            architecture=arch, release=series, label=label,
+            osystem=osystem, architecture=arch,
+            release=series, label=label,
             nodegroup=nodegroup, purpose=purpose)
         result = BootImage.objects.get_default_arch_image_in_nodegroup(
-            nodegroup, series, purpose=purpose)
+            nodegroup, osystem, series, purpose=purpose)
         self.assertEqual(result.architecture, arch)
 
     def test_default_arch_image_prefers_i386(self):
         nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
         series = factory.make_name('series')
         label = factory.make_name('label')
         purpose = factory.make_name("purpose")
         for arch in ['amd64', 'axp', 'i386', 'm88k']:
             factory.make_boot_image(
-                architecture=arch, release=series, nodegroup=nodegroup,
+                osystem=osystem, architecture=arch,
+                release=series, nodegroup=nodegroup,
                 purpose=purpose, label=label)
         result = BootImage.objects.get_default_arch_image_in_nodegroup(
-            nodegroup, series, purpose=purpose)
+            nodegroup, osystem, series, purpose=purpose)
         self.assertEqual(result.architecture, "i386")
 
     def test_default_arch_image_returns_arbitrary_pick_if_all_else_fails(self):
         nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
         series = factory.make_name('series')
         label = factory.make_name('label')
         purpose = factory.make_name("purpose")
         images = [
             factory.make_boot_image(
-                architecture=factory.make_name('arch'), release=series,
-                label=label, nodegroup=nodegroup, purpose=purpose)
+                osystem=osystem, architecture=factory.make_name('arch'),
+                release=series, label=label, nodegroup=nodegroup,
+                purpose=purpose)
             for _ in range(3)
             ]
         self.assertIn(
             BootImage.objects.get_default_arch_image_in_nodegroup(
-                nodegroup, series, purpose=purpose),
+                nodegroup, osystem, series, purpose=purpose),
             images)
 
     def test_default_arch_image_copes_with_subarches(self):
         nodegroup = factory.make_node_group()
         arch = 'i386'
+        osystem = factory.make_name('os')
         series = factory.make_name('series')
         label = factory.make_name('label')
         purpose = factory.make_name("purpose")
         images = [
             factory.make_boot_image(
-                architecture=arch, subarchitecture=factory.make_name('sub'),
+                osystem=osystem, architecture=arch,
+                subarchitecture=factory.make_name('sub'),
                 release=series, label=label, nodegroup=nodegroup,
                 purpose=purpose)
             for _ in range(3)
             ]
         self.assertIn(
             BootImage.objects.get_default_arch_image_in_nodegroup(
-                nodegroup, series, purpose=purpose),
+                nodegroup, osystem, series, purpose=purpose),
             images)
 
     def test_get_usable_architectures_returns_supported_arches(self):
@@ -164,54 +174,62 @@
             BootImage.objects.get_usable_architectures(nodegroup))
 
     def test_get_latest_image_returns_latest_image_for_criteria(self):
+        osystem = factory.make_name('os')
         arch = factory.make_name('arch')
         subarch = factory.make_name('sub')
         release = factory.make_name('release')
         nodegroup = factory.make_node_group()
         purpose = factory.make_name("purpose")
         boot_image = factory.make_boot_image(
-            nodegroup=nodegroup, architecture=arch,
+            nodegroup=nodegroup, osystem=osystem, architecture=arch,
             subarchitecture=subarch, release=release, purpose=purpose,
             label=factory.make_name('label'))
         self.assertEqual(
             boot_image,
             BootImage.objects.get_latest_image(
-                nodegroup, arch, subarch, release, purpose))
+                nodegroup, osystem, arch, subarch, release, purpose))
 
     def test_get_latest_image_doesnt_return_images_for_other_purposes(self):
+        osystem = factory.make_name('os')
         arch = factory.make_name('arch')
         subarch = factory.make_name('sub')
         release = factory.make_name('release')
         nodegroup = factory.make_node_group()
         purpose = factory.make_name("purpose")
         relevant_image = factory.make_boot_image(
-            nodegroup=nodegroup, architecture=arch,
+            nodegroup=nodegroup, osystem=osystem, architecture=arch,
             subarchitecture=subarch, release=release, purpose=purpose,
             label=factory.make_name('label'))
 
         # Create a bunch of more recent but irrelevant BootImages..
         factory.make_boot_image(
-            nodegroup=factory.make_node_group(), architecture=arch,
-            subarchitecture=subarch, release=release,
+            nodegroup=factory.make_node_group(), osystem=osystem,
+            architecture=arch, subarchitecture=subarch, release=release,
             purpose=purpose, label=factory.make_name('label'))
         factory.make_boot_image(
-            nodegroup=nodegroup,
+            nodegroup=nodegroup, osystem=osystem,
             architecture=factory.make_name('arch'),
             subarchitecture=subarch, release=release, purpose=purpose,
             label=factory.make_name('label'))
         factory.make_boot_image(
-            nodegroup=nodegroup, architecture=arch,
+            nodegroup=nodegroup, osystem=osystem, architecture=arch,
             subarchitecture=factory.make_name('subarch'),
             release=release, purpose=purpose,
             label=factory.make_name('label'))
         factory.make_boot_image(
-            nodegroup=nodegroup,
+            nodegroup=nodegroup, osystem=osystem,
             architecture=factory.make_name('arch'),
             subarchitecture=subarch,
             release=factory.make_name('release'), purpose=purpose,
             label=factory.make_name('label'))
         factory.make_boot_image(
-            nodegroup=nodegroup,
+            nodegroup=nodegroup, osystem=osystem,
+            architecture=factory.make_name('arch'),
+            subarchitecture=subarch, release=release,
+            purpose=factory.make_name('purpose'),
+            label=factory.make_name('label'))
+        factory.make_boot_image(
+            nodegroup=nodegroup, osystem=factory.make_name('os'),
             architecture=factory.make_name('arch'),
             subarchitecture=subarch, release=release,
             purpose=factory.make_name('purpose'),
@@ -220,4 +238,66 @@
         self.assertEqual(
             relevant_image,
             BootImage.objects.get_latest_image(
-                nodegroup, arch, subarch, release, purpose))
+                nodegroup, osystem, arch, subarch, release, purpose))
+
+    def test_get_usable_osystems_returns_supported_osystems(self):
+        nodegroup = factory.make_node_group()
+        osystems = [
+            factory.make_name('os'),
+            factory.make_name('os'),
+            ]
+        for osystem in osystems:
+            factory.make_boot_image(
+                osystem=osystem,
+                nodegroup=nodegroup)
+        self.assertItemsEqual(
+            osystems,
+            BootImage.objects.get_usable_osystems(nodegroup))
+
+    def test_get_usable_osystems_uses_given_nodegroup(self):
+        nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
+        factory.make_boot_image(
+            osystem=osystem, nodegroup=nodegroup)
+        self.assertItemsEqual(
+            [],
+            BootImage.objects.get_usable_osystems(
+                factory.make_node_group()))
+
+    def test_get_usable_releases_returns_supported_releases(self):
+        nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
+        releases = [
+            factory.make_name('release'),
+            factory.make_name('release'),
+            ]
+        for release in releases:
+            factory.make_boot_image(
+                osystem=osystem,
+                release=release,
+                nodegroup=nodegroup)
+        self.assertItemsEqual(
+            releases,
+            BootImage.objects.get_usable_releases(nodegroup, osystem))
+
+    def test_get_usable_releases_uses_given_nodegroup(self):
+        nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
+        release = factory.make_name('release')
+        factory.make_boot_image(
+            osystem=osystem, release=release, nodegroup=nodegroup)
+        self.assertItemsEqual(
+            [],
+            BootImage.objects.get_usable_releases(
+                factory.make_node_group(), osystem))
+
+    def test_get_usable_releases_uses_given_osystem(self):
+        nodegroup = factory.make_node_group()
+        osystem = factory.make_name('os')
+        release = factory.make_name('release')
+        factory.make_boot_image(
+            osystem=osystem, release=release, nodegroup=nodegroup)
+        self.assertItemsEqual(
+            [],
+            BootImage.objects.get_usable_releases(
+                factory.make_node_group(), factory.make_name('os')))

=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2014-04-21 11:07:32 +0000
+++ src/maasserver/models/tests/test_node.py	2014-04-24 17:04:47 +0000
@@ -20,7 +20,6 @@
 from django.core.exceptions import ValidationError
 from maasserver.clusterrpc.power_parameters import get_power_types
 from maasserver.enum import (
-    DISTRO_SERIES,
     NODE_PERMISSION,
     NODE_STATUS,
     NODE_STATUS_CHOICES,
@@ -270,17 +269,41 @@
             offset += timedelta(1)
         self.assertEqual(macs[0], node.get_primary_mac().mac_address)
 
-    def test_get_distro_series_returns_default_series(self):
-        node = factory.make_node()
-        series = Config.objects.get_config('commissioning_distro_series')
-        self.assertEqual(series, node.get_distro_series())
+    def test_get_osystem_returns_default_osystem_and_series(self):
+        node = factory.make_node()
+        osystem = Config.objects.get_config('default_osystem')
+        series = Config.objects.get_config('default_distro_series')
+        self.assertEqual(osystem, node.get_osystem())
+        self.assertEqual(series, node.get_distro_series())
+
+    def test_get_series_returns_default_for_osystem(self):
+        node = factory.make_node()
+        osystem = factory.getRandomOS()
+        series = osystem.get_default_release()
+        node.set_osystem(osystem.name)
+        self.assertEqual(series, node.get_distro_series())
+
+    def test_set_get_osystem_returns_osystem(self):
+        osystem = factory.getRandomOS()
+        node = factory.make_node()
+        node.set_osystem(osystem.name)
+        self.assertEqual(osystem.name, node.get_osystem())
 
     def test_set_get_distro_series_returns_series(self):
+        osystem = factory.getRandomOS()
+        series = factory.getRandomRelease(osystem)
         node = factory.make_node()
-        series = DISTRO_SERIES.quantal
         node.set_distro_series(series)
         self.assertEqual(series, node.get_distro_series())
 
+    def test_set_get_osystem_and_distro_series_returns_valid(self):
+        osystem = factory.getRandomOS()
+        series = factory.getRandomRelease(osystem)
+        node = factory.make_node()
+        node.set_osystem_and_distro_series(osystem.name, series)
+        self.assertEqual(osystem.name, node.get_osystem())
+        self.assertEqual(series, node.get_distro_series())
+
     def test_delete_node_deletes_related_mac(self):
         node = factory.make_node()
         mac = node.add_mac_address('AA:BB:CC:DD:EE:FF')

=== modified file 'src/maasserver/preseed.py'
--- src/maasserver/preseed.py	2014-04-10 13:43:33 +0000
+++ src/maasserver/preseed.py	2014-04-24 17:04:47 +0000
@@ -93,6 +93,7 @@
 
 def get_curtin_installer_url(node):
     """Return the URL where curtin on the node can download its installer."""
+    osystem = node.get_osystem()
     series = node.get_distro_series()
     cluster_host = pick_cluster_controller_address(node)
     # XXX rvb(?): The path shouldn't be hardcoded like this, but rather synced
@@ -100,18 +101,20 @@
     arch, subarch = node.architecture.split('/')
     purpose = 'xinstall'
     image = BootImage.objects.get_latest_image(
-        node.nodegroup, arch, subarch, series, purpose)
+        node.nodegroup, osystem, arch, subarch, series, purpose)
     if image is None:
         raise MAASAPIException(
             "Error generating the URL of curtin's root-tgz file.  "
             "No image could be found for the given selection: "
-            "arch=%s, subarch=%s, series=%s, purpose=%s." % (
+            "os=%s, arch=%s, subarch=%s, series=%s, purpose=%s." % (
+                osystem,
                 arch,
                 subarch,
                 series,
                 purpose
             ))
     dyn_uri = '/'.join([
+        osystem,
         arch,
         subarch,
         series,

=== modified file 'src/maasserver/static/js/node_add.js'
--- src/maasserver/static/js/node_add.js	2014-03-03 06:33:34 +0000
+++ src/maasserver/static/js/node_add.js	2014-04-24 17:04:47 +0000
@@ -228,11 +228,28 @@
         var heading = Y.Node.create('<h2 />')
             .set('text', "Add node");
         this.get('srcNode').append(heading).append(this.createForm());
+        this.setUpDistroSeriesField();
         this.setUpPowerParameterField();
         this.initializeNodes();
     },
 
     /**
+     * If the 'distro_series' field is present, setup the linked
+     * 'distro_series' field.
+     *
+     * @method setUpDistroSeriesField
+     */
+    setUpDistroSeriesField: function() {
+        if (Y.Lang.isValue(Y.one('#id_distro_series'))) {
+            var widget = new Y.maas.os_distro_select.OSReleaseWidget({
+                srcNode: '#id_distro_series'
+                });
+            widget.bindTo(Y.one('#id_osystem'), 'change');
+            widget.render();
+        }
+    },
+
+    /**
      * If the 'power_type' field is present, setup the linked
      * 'power_parameter' field.
      *
@@ -415,5 +432,6 @@
 };
 
 }, '0.1', {'requires': ['io', 'node', 'widget', 'event', 'event-custom',
-                        'maas.morph', 'maas.enums', 'maas.power_parameters']}
+                        'maas.morph', 'maas.enums', 'maas.power_parameters',
+                        'maas.os_distro_select']}
 );

=== added file 'src/maasserver/static/js/os_distro_select.js'
--- src/maasserver/static/js/os_distro_select.js	1970-01-01 00:00:00 +0000
+++ src/maasserver/static/js/os_distro_select.js	2014-04-24 17:04:47 +0000
@@ -0,0 +1,131 @@
+/* Copyright 2012-2014 Canonical Ltd.  This software is licensed under the
+ * GNU Affero General Public License version 3 (see the file LICENSE).
+ *
+ * OS/Release seletion utilities.
+ *
+ * @module Y.maas.power_parameter
+ */
+
+YUI.add('maas.os_distro_select', function(Y) {
+
+Y.log('loading maas.os_distro_select');
+var module = Y.namespace('maas.os_distro_select');
+
+// Only used to mockup io in tests.
+module._io = new Y.IO();
+
+var OSReleaseWidget;
+
+/**
+ * A widget class used to have the content of a node's release <select>
+ * modified based on the selected operating system.
+ *
+ */
+OSReleaseWidget = function() {
+    OSReleaseWidget.superclass.constructor.apply(this, arguments);
+};
+
+OSReleaseWidget.NAME = 'os-release-widget';
+
+Y.extend(OSReleaseWidget, Y.Widget, {
+
+   /**
+    * Initialize the widget.
+    * - cfg.srcNode is the node which will be updated when the selected
+    *   value of the 'os node' will change.
+    * - cfg.osNode is the node containing a 'select' element.  When
+    *   the selected element will change, the srcNode HTML will be
+    *   updated.
+    *
+    * @method initializer
+    */
+    initializer: function(cfg) {
+        this.initialSkip = true;
+    },
+
+   /**
+    * Bind the widget to events (to name 'event_name') generated by the given
+    * 'osNode'.
+    *
+    * @method bindTo
+    */
+    bindTo: function(osNode, event_name) {
+        var self = this;
+        Y.one(osNode).on(event_name, function(e) {
+            var osValue = e.currentTarget.get('value');
+            self.switchTo(osValue);
+        });
+        var osValue = Y.one(osNode).get('value');
+        self.switchTo(osValue);
+    },
+
+   /**
+    * React to a new value of the os node: update the HTML of
+    * 'srcNode'.
+    *
+    * @method switchTo
+    */
+    switchTo: function(newOSValue) {
+        var srcNode = this.get('srcNode');
+        var options = srcNode.all('option');
+        var selected = false;
+        options.each(function(option) {
+            var value = option.get('value');
+            var split_value = value.split("/");
+
+            // Only show the default option, if that
+            // is the selected os option as well.
+            if(newOSValue == '') {
+                if(value == '') {
+                    option.removeClass('hidden');
+                    option.set('selected', 'selected');
+                }
+                else {
+                    option.addClass('hidden');
+                }
+            }
+            else {
+                if(split_value[0] == newOSValue) {
+                    option.removeClass('hidden');
+                    if(split_value[1] == '') {
+                        selected = true;
+                        option.set('selected', 'selected');
+                    }
+                }
+                else {
+                    option.addClass('hidden');
+                }
+            }
+        });
+
+        // See if this was the inital skip. As the following
+        // should only be done, after the first load, as the
+        // initial will already be selected correctly.
+        if(this.initialSkip == true) {
+            this.initialSkip = false;
+            return;
+        }
+
+        // See if a selection was made, if not then we need
+        // to select the first visible as a default is not
+        // present.
+        if(!selected) {
+            var first_option = null;
+            options.each(function(option) {
+                if(!option.hasClass('hidden')) {
+                    if(first_option == null) {
+                        first_option = option;
+                    }   
+                }
+            });
+            if(first_option != null) {
+                first_option.set('selected', 'selected');
+            }
+        }
+    }
+});
+
+module.OSReleaseWidget = OSReleaseWidget;
+
+}, '0.1', {'requires': ['widget', 'io']}
+);

=== added file 'src/maasserver/static/js/tests/test_os_distro_select.html'
--- src/maasserver/static/js/tests/test_os_distro_select.html	1970-01-01 00:00:00 +0000
+++ src/maasserver/static/js/tests/test_os_distro_select.html	2014-04-24 17:04:47 +0000
@@ -0,0 +1,38 @@
+<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
+<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
+  <head>
+    <title>Test maas.os_distro_select</title>
+
+    <!-- YUI and test setup -->
+    <script type="text/javascript" src="../testing/yui_test_conf.js"></script>
+    <script type="text/javascript" src="/usr/share/javascript/yui3/yui/yui.js"></script>
+    <script type="text/javascript" src="../testing/testrunner.js"></script>
+    <script type="text/javascript" src="../testing/testing.js"></script>
+    <!-- The module under test -->
+    <script type="text/javascript" src="../os_distro_select.js"></script>
+    <!-- The test suite -->
+    <script type="text/javascript" src="test_os_distro_select.js"></script>
+  </head>
+  <body>
+  <span id="suite">maas.os_distro_select.tests</span>
+  <script type="text/x-template" id="select_node">
+    <select id="id_osystem">
+      <option value="" selected="selected">Default OS</option>
+      <option value="value1">Value1</option>
+      <option value="value2">Value2</option>
+    </select>
+  </script>
+  <script type="text/x-template" id="target_node">
+    <select id="id_distro_series">
+      <option value="" selected="selected">Default Release</option>
+      <option value="value1/series1">Value1Series1</option>
+      <option value="value1/series2">Value1Series2</option>
+      <option value="value1/series3">Value1Series3</option>
+      <option value="value2/series1">Value2Series1</option>
+      <option value="value2/series2">Value2Series2</option>
+      <option value="value2/series3">Value2Series3</option>
+    </select>
+  </script>
+  <div id="placeholder"></div>
+  </body>
+</html>

=== added file 'src/maasserver/static/js/tests/test_os_distro_select.js'
--- src/maasserver/static/js/tests/test_os_distro_select.js	1970-01-01 00:00:00 +0000
+++ src/maasserver/static/js/tests/test_os_distro_select.js	2014-04-24 17:04:47 +0000
@@ -0,0 +1,106 @@
+/* Copyright 2012 Canonical Ltd.  This software is licensed under the
+ * GNU Affero General Public License version 3 (see the file LICENSE).
+ */
+
+YUI({ useBrowserConsole: true }).add(
+    'maas.os_distro_select.tests', function(Y) {
+
+Y.log('loading maas.os_distro_select.tests');
+var namespace = Y.namespace('maas.os_distro_select.tests');
+
+var module = Y.maas.os_distro_select;
+var suite = new Y.Test.Suite("maas.os_distro_select Tests");
+
+var select_node_template = Y.one('#select_node').getContent();
+var target_node_template = Y.one('#target_node').getContent();
+
+suite.add(new Y.maas.testing.TestCase({
+    name: 'test-os_distro_select',
+
+    setUp: function () {
+        Y.one('#placeholder').empty().append(
+            Y.Node.create(select_node_template).append(
+                Y.Node.create(target_node_template)));
+    },
+
+    testBindToDefaultShowsDefaultRelease: function() {
+        var widget = new Y.maas.os_distro_select.OSReleaseWidget({
+            srcNode: '#id_distro_series',
+            });
+        widget.bindTo(Y.one('#id_osystem'), 'change');
+
+        var options = Y.one('#id_distro_series').all('option');
+        options.each(function(option) {
+            var value = option.get('value');
+            if(value == '') {
+                Y.Assert.isFalse(option.hasClass('hidden'));
+            }
+            else {
+                Y.Assert.isTrue(option.hasClass('hidden'));
+            }
+        });
+    },
+
+    testNonDefaultShowsRelatedReleases: function() {
+        var node = Y.one('#id_distro_series');
+        node.append('<option value="value1/">Value1Default</option>');
+
+        var widget = new Y.maas.os_distro_select.OSReleaseWidget({
+            srcNode: '#id_distro_series',
+            });
+        widget.bindTo(Y.one('#id_osystem'), 'change');
+
+        var newValue = 'value1';
+        var select = Y.one('#id_osystem');
+        select.set('value', newValue);
+        select.simulate('change');
+
+        var options = Y.one('#id_distro_series').all('option');
+        options.each(function(option) {
+            var value = option.get('value');
+            if(value == '') {
+                Y.Assert.isTrue(option.hasClass('hidden'));
+            }
+            else {
+                var split_value = value.split('/');
+                if(split_value[0] == newValue) {
+                    Y.Assert.isFalse(option.hasClass('hidden'));
+                }
+                else {
+                    Y.Assert.isTrue(option.hasClass('hidden'));
+                }
+            }
+        });
+
+        Y.Assert.areEqual(
+            newValue + '/', Y.one('#id_distro_series').get('value'))
+    },
+
+    testInitialSkipOnFirstChange: function() {
+        var newValue = 'value1/series1';
+        var select = Y.one('#id_osystem');
+        select.set('value', 'value1');
+        select.simulate('change');
+        select = Y.one('#id_distro_series');
+        select.set('value', newValue);
+        select.simulate('change');
+
+        var widget = new Y.maas.os_distro_select.OSReleaseWidget({
+            srcNode: '#id_distro_series',
+            });
+
+        Y.Assert.isTrue(widget.initialSkip);
+        widget.bindTo(Y.one('#id_osystem'), 'change');
+        Y.Assert.isFalse(widget.initialSkip);
+
+        Y.Assert.areEqual(
+            newValue, Y.one('#id_distro_series').get('value'))
+    }
+
+}));
+
+namespace.suite = suite;
+
+}, '0.1', {'requires': [
+    'node-event-simulate', 'test', 'maas.testing', 'maas.os_distro_select']}
+);

=== modified file 'src/maasserver/templates/maasserver/bootimage-list.html'
--- src/maasserver/templates/maasserver/bootimage-list.html	2014-03-27 07:39:38 +0000
+++ src/maasserver/templates/maasserver/bootimage-list.html	2014-04-24 17:04:47 +0000
@@ -20,6 +20,7 @@
           <thead>
             <tr>
               <th>ID</th>
+              <th>OS</th>
               <th>Release</th>
               <th>Architecture</th>
               <th>Subarchitecture</th>
@@ -32,6 +33,7 @@
         {% for bootimage in bootimage_list %}
           <tr class="bootimage {% cycle 'even' 'odd' %}">
             <td>{{ bootimage.id }}</td>
+            <td>{{ bootimage.osystem_title }}</td>
             <td>{{ bootimage.release }}</td>
             <td>{{ bootimage.architecture }}</td>
             <td>{{ bootimage.subarchitecture }}</td>

=== modified file 'src/maasserver/templates/maasserver/node_edit.html'
--- src/maasserver/templates/maasserver/node_edit.html	2014-03-03 09:44:25 +0000
+++ src/maasserver/templates/maasserver/node_edit.html	2014-04-24 17:04:47 +0000
@@ -11,9 +11,17 @@
   <script type="text/javascript">
   <!--
   YUI().use(
-    'maas.enums', 'maas.power_parameters',
+    'maas.enums', 'maas.power_parameters', 'maas.os_distro_select',
     function (Y) {
     Y.on('load', function() {
+      // Create OSDistroWidget so that the release field will be
+      // updated each time the value of the os field changes.
+      var releaseWidget = new Y.maas.os_distro_select.OSReleaseWidget({
+          srcNode: '#id_distro_series'
+          });
+      releaseWidget.bindTo(Y.one('.osystem').one('select'), 'change');
+      releaseWidget.render();
+
       // Create LinkedContentWidget widget so that the power_parameter field
       // will be updated each time the value of the power_type field changes.
       var power_types = {{ power_types }};

=== modified file 'src/maasserver/templates/maasserver/settings.html'
--- src/maasserver/templates/maasserver/settings.html	2014-04-10 04:29:20 +0000
+++ src/maasserver/templates/maasserver/settings.html	2014-04-24 17:04:47 +0000
@@ -6,6 +6,23 @@
 {% block page-title %}Settings{% endblock %}
 
 {% block head %}
+  <script type="text/javascript">
+  <!--
+  YUI().use(
+    'maas.os_distro_select',
+    function (Y) {
+    Y.on('load', function() {
+      // Create OSDistroWidget so that the release field will be
+      // updated each time the value of the os field changes.
+      var releaseWidget = new Y.maas.os_distro_select.OSReleaseWidget({
+          srcNode: '#id_deploy-default_distro_series'
+          });
+      releaseWidget.bindTo(Y.one('#id_deploy-default_osystem'), 'change');
+      releaseWidget.render();
+    });
+  });
+  // -->
+  </script>
 {% endblock %}
 
 {% block content %}
@@ -90,6 +107,21 @@
       <div class="clear"></div>
     </div>
     <div class="divider"></div>
+    <div id="deploy" class="block size7 first">
+      <h2>Deploy</h2>
+      <form action="{% url "settings" %}" method="post">
+        {% csrf_token %}
+        <ul>
+        {% for field in deploy_form %}
+          {% include "maasserver/form_field.html" %}
+        {% endfor %}
+        </ul>
+        <input type="hidden" name="deploy_submit" value="1" />
+        <input type="submit" class="button right" value="Save" />
+      </form>
+      <div class="clear"></div>
+    </div>
+    <div class="divider"></div>
     <div id="ubuntu" class="block size7 first">
       <h2>Ubuntu</h2>
       <form action="{% url "settings" %}" method="post">

=== modified file 'src/maasserver/templates/maasserver/snippets.html'
--- src/maasserver/templates/maasserver/snippets.html	2014-03-25 13:45:52 +0000
+++ src/maasserver/templates/maasserver/snippets.html	2014-04-24 17:04:47 +0000
@@ -16,6 +16,10 @@
     </div>
   </p>
   <p>
+    <label for="id_osystem">OS</label>
+    {{ node_form.osystem }}
+  </p>
+  <p>
     <label for="id_distro_series">Release</label>
     {{ node_form.distro_series }}
   </p>

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2014-04-04 06:46:05 +0000
+++ src/maasserver/testing/factory.py	2014-04-24 17:04:47 +0000
@@ -56,6 +56,7 @@
     NodeCommissionResult,
     )
 from netaddr import IPAddress
+from provisioningserver.osystems import OperatingSystemRegistry
 
 # We have a limited number of public keys:
 # src/maasserver/tests/data/test_rsa{0, 1, 2, 3, 4}.pub
@@ -137,6 +138,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]
@@ -427,9 +443,11 @@
         return "OAuth " + ", ".join([
             '%s="%s"' % (key, value) for key, value in items.items()])
 
-    def make_boot_image(self, architecture=None, subarchitecture=None,
-                        release=None, purpose=None, nodegroup=None,
-                        label=None):
+    def make_boot_image(self, osystem=None, architecture=None,
+                        subarchitecture=None, release=None, purpose=None,
+                        nodegroup=None, label=None):
+        if osystem is None:
+            osystem = self.make_name('os')
         if architecture is None:
             architecture = self.make_name('architecture')
         if subarchitecture is None:
@@ -444,6 +462,7 @@
             label = self.make_name('label')
         return BootImage.objects.create(
             nodegroup=nodegroup,
+            osystem=osystem,
             architecture=architecture,
             subarchitecture=subarchitecture,
             release=release,

=== 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-04-24 17:04:47 +0000
@@ -0,0 +1,94 @@
+# 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.osystems import BOOT_IMAGE_PURPOSE
+from provisioningserver.boot.tests.test_tftppath import make_osystem
+
+
+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`.
+    """
+    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)]
+
+    osystem = make_osystem(
+        osystem_name,
+        [BOOT_IMAGE_PURPOSE.INSTALL, BOOT_IMAGE_PURPOSE.XINSTALL],
+        testcase)
+    osystem.fake_list = releases
+    return osystem
+
+
+def patch_usable_osystems(testcase, osystems=None, allow_empty=True):
+    """Set a fixed list of usable oeprating systems.
+
+    A usable operating system is one for which boot images are available.
+
+    :param testcase: A `TestCase` whose `patch` this function can use.
+    :param architectures: Optional list of oprating 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()
+    patch = testcase.patch(forms, 'list_all_usable_osystems')
+    patch.return_value = osystems
+    patch = testcase.patch(forms, 'list_all_usable_releases')
+    patch.return_value = distro_series
+
+
+def make_usable_osystem(testcase, with_releases=True, 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 with_releases: Should the operating system include releases?
+        Defaults to `True`.
+    :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, with_releases=with_releases, osystem_name=osystem_name,
+        releases=releases)
+    patch_usable_osystems(testcase, [osystem])
+    return osystem

=== modified file 'src/maasserver/tests/test_api_boot_images.py'
--- src/maasserver/tests/test_api_boot_images.py	2014-03-21 19:01:40 +0000
+++ src/maasserver/tests/test_api_boot_images.py	2014-04-24 17:04:47 +0000
@@ -134,6 +134,7 @@
         image = factory.make_boot_image()
         self.assertEqual(
             (
+                image.osystem,
                 image.architecture,
                 image.subarchitecture,
                 image.release,
@@ -146,6 +147,7 @@
         image = make_boot_image_params()
         self.assertEqual(
             (
+                image['osystem'],
                 image['architecture'],
                 image['subarchitecture'],
                 image['release'],
@@ -158,12 +160,13 @@
         image = make_boot_image_params()
         del image['subarchitecture']
         del image['label']
-        _, subarchitecture, _, label, _ = summarise_boot_image_dict(image)
+        _, _, subarchitecture, _, label, _ = summarise_boot_image_dict(image)
         self.assertEqual(('generic', 'release'), (subarchitecture, label))
 
     def test_summarise_boot_image_functions_are_compatible(self):
         image_dict = make_boot_image_params()
         image_obj = factory.make_boot_image(
+            osystem=image_dict['osystem'],
             architecture=image_dict['architecture'],
             subarchitecture=image_dict['subarchitecture'],
             release=image_dict['release'], label=image_dict['label'],

=== modified file 'src/maasserver/tests/test_api_node.py'
--- src/maasserver/tests/test_api_node.py	2014-04-22 10:26:47 +0000
+++ src/maasserver/tests/test_api_node.py	2014-04-24 17:04:47 +0000
@@ -23,7 +23,6 @@
 import bson
 from django.core.urlresolvers import reverse
 from maasserver.enum import (
-    DISTRO_SERIES,
     NODE_STATUS,
     NODE_STATUS_CHOICES_DICT,
     )
@@ -48,6 +47,7 @@
     NodeUserData,
     )
 from metadataserver.nodeinituser import get_node_init_user
+from provisioningserver.osystems.ubuntu import UbuntuOS
 
 
 class NodeAnonAPITest(MAASServerTestCase):
@@ -221,11 +221,60 @@
         self.assertEqual(
             node.system_id, json.loads(response.content)['system_id'])
 
-    def test_POST_start_sets_distro_series(self):
-        node = factory.make_node(
-            owner=self.logged_in_user, mac=True,
-            power_type='ether_wake')
-        distro_series = factory.getRandomEnum(DISTRO_SERIES)
+    def test_POST_start_sets_osystem(self):
+        node = factory.make_node(
+            owner=self.logged_in_user, mac=True,
+            power_type='ether_wake')
+        osystem = factory.getRandomOS()
+        response = self.client.post(
+            self.get_node_uri(node),
+            {'op': 'start', 'osystem': osystem.name})
+        self.assertEqual(
+            (httplib.OK, node.system_id),
+            (response.status_code, json.loads(response.content)['system_id']))
+        self.assertEqual(
+            osystem.name, reload_object(node).osystem)
+
+    def test_POST_start_accepts_os(self):
+        node = factory.make_node(
+            owner=self.logged_in_user, mac=True,
+            power_type='ether_wake')
+        osystem = factory.getRandomOS()
+        response = self.client.post(
+            self.get_node_uri(node),
+            {'op': 'start', 'os': osystem.name})
+        self.assertEqual(
+            (httplib.OK, node.system_id),
+            (response.status_code, json.loads(response.content)['system_id']))
+        self.assertEqual(
+            osystem.name, reload_object(node).osystem)
+
+    def test_POST_start_sets_osystem_and_distro_series(self):
+        node = factory.make_node(
+            owner=self.logged_in_user, mac=True,
+            power_type='ether_wake')
+        osystem = factory.getRandomOS()
+        distro_series = factory.getRandomRelease(osystem)
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'osystem': osystem.name,
+                'distro_series': distro_series
+                })
+        self.assertEqual(
+            (httplib.OK, node.system_id),
+            (response.status_code, json.loads(response.content)['system_id']))
+        self.assertEqual(
+            osystem.name, reload_object(node).osystem)
+        self.assertEqual(
+            distro_series, reload_object(node).distro_series)
+
+    def test_POST_start_sets_distro_series_defaults_ubuntu(self):
+        node = factory.make_node(
+            owner=self.logged_in_user, mac=True,
+            power_type='ether_wake')
+        osystem = UbuntuOS()
+        distro_series = factory.getRandomRelease(osystem)
         response = self.client.post(
             self.get_node_uri(node),
             {'op': 'start', 'distro_series': distro_series})
@@ -233,8 +282,27 @@
             (httplib.OK, node.system_id),
             (response.status_code, json.loads(response.content)['system_id']))
         self.assertEqual(
+            osystem.name, reload_object(node).osystem)
+        self.assertEqual(
             distro_series, reload_object(node).distro_series)
 
+    def test_POST_start_validates_osystem(self):
+        node = factory.make_node(
+            owner=self.logged_in_user, mac=True,
+            power_type='ether_wake')
+        invalid_osystem = factory.getRandomString()
+        response = self.client.post(
+            self.get_node_uri(node),
+            {'op': 'start', 'osystem': invalid_osystem})
+        self.assertEqual(
+            (
+                httplib.BAD_REQUEST,
+                {'osystem': [
+                    "Value u'%s' is not a valid choice." %
+                    invalid_osystem]}
+            ),
+            (response.status_code, json.loads(response.content)))
+
     def test_POST_start_validates_distro_series(self):
         node = factory.make_node(
             owner=self.logged_in_user, mac=True,
@@ -300,18 +368,23 @@
         self.client.post(self.get_node_uri(node), {'op': 'release'})
         self.assertTrue(reload_object(node).netboot)
 
-    def test_POST_release_resets_distro_series(self):
+    def test_POST_release_resets_osystem_and_distro_series(self):
+        osystem = factory.getRandomOS()
+        release = factory.getRandomRelease(osystem)
         node = factory.make_node(
             status=NODE_STATUS.ALLOCATED, owner=self.logged_in_user,
-            distro_series=factory.getRandomEnum(DISTRO_SERIES))
+            osystem=osystem.name, distro_series=release)
         self.client.post(self.get_node_uri(node), {'op': 'release'})
+        self.assertEqual('', reload_object(node).osystem)
         self.assertEqual('', reload_object(node).distro_series)
 
     def test_POST_release_resets_agent_name(self):
         agent_name = factory.make_name('agent-name')
+        osystem = factory.getRandomOS()
+        release = factory.getRandomRelease(osystem)
         node = factory.make_node(
             status=NODE_STATUS.ALLOCATED, owner=self.logged_in_user,
-            distro_series=factory.getRandomEnum(DISTRO_SERIES),
+            osystem=osystem.name, distro_series=release,
             agent_name=agent_name)
         self.client.post(self.get_node_uri(node), {'op': 'release'})
         self.assertEqual('', reload_object(node).agent_name)

=== modified file 'src/maasserver/tests/test_api_pxeconfig.py'
--- src/maasserver/tests/test_api_pxeconfig.py	2014-03-27 04:15:45 +0000
+++ src/maasserver/tests/test_api_pxeconfig.py	2014-04-24 17:04:47 +0000
@@ -133,9 +133,11 @@
         self.assertEqual(value, response_dict['extra_opts'])
 
     def test_pxeconfig_uses_present_boot_image(self):
+        osystem = Config.objects.get_config('commissioning_osystem')
         release = Config.objects.get_config('commissioning_distro_series')
         nodegroup = factory.make_node_group()
         factory.make_boot_image(
+            osystem=osystem,
             architecture="amd64", release=release, nodegroup=nodegroup,
             purpose="commissioning")
         params = self.get_default_params()
@@ -282,7 +284,8 @@
     def test_get_boot_purpose_unknown_node(self):
         # A node that's not yet known to MAAS is assumed to be enlisting,
         # which uses a "commissioning" image.
-        self.assertEqual("commissioning", api.get_boot_purpose(None))
+        self.assertEqual("commissioning", api.get_boot_purpose(
+            None, None, None, None, None, None))
 
     def test_get_boot_purpose_known_node(self):
         # The following table shows the expected boot "purpose" for each set
@@ -305,11 +308,17 @@
                 node.use_fastpath_installer()
             for name, value in parameters.items():
                 setattr(node, name, value)
-            self.assertEqual(purpose, api.get_boot_purpose(node))
+            osystem = node.get_osystem()
+            series = node.get_distro_series()
+            arch, subarch = node.architecture.split('/')
+            self.assertEqual(
+                purpose,
+                api.get_boot_purpose(
+                    node, osystem, arch, subarch, series, None))
 
     def test_pxeconfig_uses_boot_purpose(self):
         fake_boot_purpose = factory.make_name("purpose")
-        self.patch(api, "get_boot_purpose", lambda node: fake_boot_purpose)
+        self.patch(api, "get_boot_purpose").return_value = fake_boot_purpose
         response = self.client.get(reverse('pxeconfig'),
                                    self.get_default_params())
         self.assertEqual(

=== modified file 'src/maasserver/tests/test_compose_preseed.py'
--- src/maasserver/tests/test_compose_preseed.py	2013-10-07 09:12:40 +0000
+++ src/maasserver/tests/test_compose_preseed.py	2014-04-24 17:04:47 +0000
@@ -17,8 +17,10 @@
 from maasserver.compose_preseed import compose_preseed
 from maasserver.enum import NODE_STATUS
 from maasserver.testing.factory import factory
+from maasserver.testing.osystems import make_usable_osystem
 from maasserver.testing.testcase import MAASServerTestCase
 from maasserver.utils import absolute_reverse
+from maastesting.matchers import MockCalledOnceWith
 from metadataserver.models import NodeKey
 from testtools.matchers import (
     KeysEqual,
@@ -110,3 +112,15 @@
         self.assertEqual(
             absolute_reverse('curtin-metadata'),
             preseed['datasource']['MAAS']['metadata_url'])
+
+    def test_compose_preseed_with_osystem_compose_preseed(self):
+        osystem = make_usable_osystem(self)
+        mock_compose = self.patch(osystem, 'compose_preseed')
+        node = factory.make_node(osystem=osystem.name, status=NODE_STATUS.READY)
+
+        token = NodeKey.objects.get_token_for_node(node)
+        url = absolute_reverse('metadata')
+        compose_preseed(node)
+        self.assertThat(
+            mock_compose,
+            MockCalledOnceWith(node, token, url))

=== modified file 'src/maasserver/tests/test_forms.py'
--- src/maasserver/tests/test_forms.py	2014-04-22 09:08:02 +0000
+++ src/maasserver/tests/test_forms.py	2014-04-24 17:04:47 +0000
@@ -90,6 +90,11 @@
     make_usable_architecture,
     patch_usable_architectures,
     )
+from maasserver.testing.osystems import (
+    make_osystem_with_releases,
+    make_usable_osystem,
+    patch_usable_osystems,
+    )
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
 from maasserver.utils import map_enum
@@ -421,6 +426,7 @@
             [
                 'hostname',
                 'architecture',
+                'osystem',
                 'distro_series',
                 'nodegroup',
             ], list(form.fields))
@@ -480,6 +486,64 @@
             [NO_ARCHITECTURES_AVAILABLE],
             form.errors['architecture'])
 
+    def test_accepts_osystem(self):
+        osystem = make_usable_osystem(self)
+        form = NodeForm(data={
+            'hostname': factory.make_name('host'),
+            'architecture': make_usable_architecture(self),
+            'osystem': osystem.name,
+            })
+        self.assertTrue(form.is_valid(), form._errors)
+
+    def test_rejects_invalid_osystem(self):
+        patch_usable_osystems(self)
+        form = NodeForm(data={
+            'hostname': factory.make_name('host'),
+            'architecture': make_usable_architecture(self),
+            'osystem': factory.make_name('os'),
+            })
+        self.assertFalse(form.is_valid())
+        self.assertItemsEqual(['osystem'], form._errors.keys())
+
+    def test_starts_with_default_osystem(self):
+        osystems = [make_osystem_with_releases(self) for _ in range(5)]
+        patch_usable_osystems(self, osystems)
+        form = NodeForm()
+        self.assertEqual(
+            '',
+            form.fields['osystem'].initial)
+
+    def test_accepts_osystem_distro_series(self):
+        osystem = make_usable_osystem(self)
+        release = osystem.get_default_release()
+        form = NodeForm(data={
+            'hostname': factory.make_name('host'),
+            'architecture': make_usable_architecture(self),
+            'osystem': osystem.name,
+            'distro_series': '%s/%s' % (osystem.name, release),
+            })
+        self.assertTrue(form.is_valid(), form._errors)
+
+    def test_rejects_invalid_osystem_distro_series(self):
+        osystem = make_usable_osystem(self)
+        release = factory.make_name('release')
+        form = NodeForm(data={
+            'hostname': factory.make_name('host'),
+            'architecture': make_usable_architecture(self),
+            'osystem': osystem.name,
+            'distro_series': '%s/%s' % (osystem.name, release),
+            })
+        self.assertFalse(form.is_valid())
+        self.assertItemsEqual(['distro_series'], form._errors.keys())
+
+    def test_starts_with_default_distro_series(self):
+        osystems = [make_osystem_with_releases(self) for _ in range(5)]
+        patch_usable_osystems(self, osystems)
+        form = NodeForm()
+        self.assertEqual(
+            '',
+            form.fields['distro_series'].initial)
+
 
 class TestAdminNodeForm(MAASServerTestCase):
 
@@ -491,6 +555,7 @@
             [
                 'hostname',
                 'architecture',
+                'osystem',
                 'distro_series',
                 'power_type',
                 'power_parameters',

=== modified file 'src/maasserver/tests/test_preseed.py'
--- src/maasserver/tests/test_preseed.py	2014-04-21 11:43:26 +0000
+++ src/maasserver/tests/test_preseed.py	2014-04-24 17:04:47 +0000
@@ -22,7 +22,6 @@
 from django.conf import settings
 from django.core.urlresolvers import reverse
 from maasserver.enum import (
-    DISTRO_SERIES,
     NODE_STATUS,
     NODEGROUPINTERFACE_MANAGEMENT,
     PRESEED_TYPE,
@@ -590,6 +589,7 @@
         node = factory.make_node()
         arch, subarch = node.architecture.split('/')
         factory.make_boot_image(
+            osystem=node.get_osystem(),
             architecture=arch, subarchitecture=subarch,
             release=node.get_distro_series(), purpose='xinstall',
             nodegroup=node.nodegroup)
@@ -677,34 +677,37 @@
         self.assertIn('cloud-init', context['curtin_preseed'])
 
     def test_get_curtin_installer_url_returns_url(self):
-        # Exclude DISTRO_SERIES.default. It's a special value that defers
-        # to a run-time setting which we don't provide in this test.
-        series = factory.getRandomEnum(
-            DISTRO_SERIES, but_not=DISTRO_SERIES.default)
+        osystem = factory.getRandomOS()
+        series = factory.getRandomRelease(osystem)
         architecture = make_usable_architecture(self)
         node = factory.make_node(
-            architecture=architecture, distro_series=series)
+            osystem=osystem.name, architecture=architecture,
+            distro_series=series)
         arch, subarch = architecture.split('/')
         boot_image = factory.make_boot_image(
-            architecture=arch, subarchitecture=subarch, release=series,
+            osystem=osystem.name, architecture=arch,
+            subarchitecture=subarch, release=series,
             purpose='xinstall', nodegroup=node.nodegroup)
 
         installer_url = get_curtin_installer_url(node)
 
         [interface] = node.nodegroup.get_managed_interfaces()
         self.assertEqual(
-            'http://%s/MAAS/static/images/%s/%s/%s/%s/root-tgz' % (
-                interface.ip, arch, subarch, series, boot_image.label),
+            'http://%s/MAAS/static/images/%s/%s/%s/%s/%s/root-tgz' % (
+                interface.ip, osystem.name, arch, subarch,
+                series, boot_image.label),
             installer_url)
 
     def test_get_curtin_installer_url_fails_if_no_boot_image(self):
-        series = factory.getRandomEnum(
-            DISTRO_SERIES, but_not=DISTRO_SERIES.default)
+        osystem = factory.getRandomOS()
+        series = factory.getRandomRelease(osystem)
         architecture = make_usable_architecture(self)
         node = factory.make_node(
+            osystem=osystem.name,
             architecture=architecture, distro_series=series)
         # Generate a boot image with a different arch/subarch.
         factory.make_boot_image(
+            osystem=osystem.name,
             architecture=factory.make_name('arch'),
             subarchitecture=factory.make_name('subarch'), release=series,
             purpose='xinstall', nodegroup=node.nodegroup)
@@ -714,7 +717,8 @@
         arch, subarch = architecture.split('/')
         msg = (
             "No image could be found for the given selection: "
-            "arch=%s, subarch=%s, series=%s, purpose=xinstall." % (
+            "os=%s, arch=%s, subarch=%s, series=%s, purpose=xinstall." % (
+                osystem.name,
                 arch,
                 subarch,
                 node.get_distro_series(),

=== modified file 'src/maasserver/views/clusters.py'
--- src/maasserver/views/clusters.py	2014-04-03 11:20:03 +0000
+++ src/maasserver/views/clusters.py	2014-04-24 17:04:47 +0000
@@ -51,6 +51,7 @@
     NodeGroupInterface,
     )
 from maasserver.views import PaginatedListView
+from provisioningserver.osystems import OperatingSystemRegistry
 
 
 class ClusterListView(PaginatedListView, FormMixin, ProcessFormView):
@@ -270,15 +271,23 @@
         nodegroup_uuid = self.kwargs.get('uuid', None)
         return get_object_or_404(NodeGroup, uuid=nodegroup_uuid)
 
+    def get_osystem_title(self, osystem):
+        osystem_obj = OperatingSystemRegistry.get_item(osystem, default=None)
+        if osystem_obj is None:
+            return osystem
+        return osystem_obj.title
+
     def get_context_data(self, **kwargs):
         context = super(
             BootImagesListView, self).get_context_data(**kwargs)
         context['nodegroup'] = self.get_nodegroup()
+        for bootimage in context['bootimage_list']:
+            bootimage.osystem_title = self.get_osystem_title(bootimage.osystem)
         return context
 
     def get_queryset(self):
         nodegroup = self.get_nodegroup()
         # A sorted bootimages list.
         return nodegroup.bootimage_set.all().order_by(
-            '-release', 'architecture', 'subarchitecture', 'purpose',
-            'label')
+            'osystem', '-release', 'architecture', 'subarchitecture',
+            'purpose', 'label')

=== modified file 'src/maasserver/views/settings.py'
--- src/maasserver/views/settings.py	2014-04-10 13:43:33 +0000
+++ src/maasserver/views/settings.py	2014-04-24 17:04:47 +0000
@@ -41,6 +41,7 @@
 from maasserver.exceptions import CannotDeleteUserException
 from maasserver.forms import (
     CommissioningForm,
+    DeployForm,
     EditUserForm,
     GlobalKernelOptsForm,
     MAASAndNetworkForm,
@@ -177,6 +178,13 @@
     if response is not None:
         return response
 
+    # Process the Deploy form.
+    deploy_form, response = process_form(
+        request, DeployForm, reverse('settings'), 'deploy',
+        "Configuration updated.")
+    if response is not None:
+        return response
+
     # Process the Ubuntu form.
     ubuntu_form, response = process_form(
         request, UbuntuForm, reverse('settings'), 'ubuntu',
@@ -202,6 +210,7 @@
             'maas_and_network_form': maas_and_network_form,
             'third_party_drivers_form': third_party_drivers_form,
             'commissioning_form': commissioning_form,
+            'deploy_form': deploy_form,
             'ubuntu_form': ubuntu_form,
             'kernelopts_form': kernelopts_form,
         },

=== modified file 'src/maasserver/views/tests/test_boot_image_list.py'
--- src/maasserver/views/tests/test_boot_image_list.py	2014-04-02 13:53:19 +0000
+++ src/maasserver/views/tests/test_boot_image_list.py	2014-04-24 17:04:47 +0000
@@ -22,6 +22,7 @@
 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
 
 
@@ -32,6 +33,7 @@
         nodegroup = factory.make_node_group()
         images = [
             factory.make_boot_image(nodegroup=nodegroup) for _ in range(3)]
+        [make_osystem(bi.osystem, ['install'], self) for bi in images]
         response = self.client.get(
             reverse('cluster-bootimages-list', args=[nodegroup.uuid]))
         self.assertEqual(
@@ -54,8 +56,11 @@
         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)
+            ]
+        [make_osystem(bi.osystem, ['install'], self) for bi in boot_images]
         response = self.client.get(
             reverse('cluster-bootimages-list', args=[nodegroup.uuid]))
         self.assertEqual(httplib.OK, response.status_code)
@@ -66,7 +71,8 @@
 
     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)]
+        [make_osystem(bi.osystem, ['install'], self) for bi in boot_images]
         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-04 06:46:05 +0000
+++ src/maasserver/views/tests/test_clusters.py	2014-04-24 17:04:47 +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,11 @@
     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)
+            ]
+        [make_osystem(bi.osystem, ['install'], self) for bi in boot_images]
         response = self.client.get(
             reverse('cluster-edit', args=[nodegroup.uuid]))
         self.assertEqual(
@@ -320,7 +325,8 @@
 
     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)]
+        [make_osystem(bi.osystem, ['install'], self) for bi in boot_images]
         self.client_log_in(as_admin=True)
         nodegroup = factory.make_node_group()
         response = self.client.get(

=== modified file 'src/maasserver/views/tests/test_settings.py'
--- src/maasserver/views/tests/test_settings.py	2014-04-10 13:43:33 +0000
+++ src/maasserver/views/tests/test_settings.py	2014-04-24 17:04:47 +0000
@@ -20,10 +20,7 @@
 from django.contrib.auth.models import User
 from django.core.urlresolvers import reverse
 from lxml.html import fromstring
-from maasserver.enum import (
-    COMMISSIONING_DISTRO_SERIES_CHOICES,
-    DISTRO_SERIES,
-    )
+from maasserver.models.config import DEFAULT_OS
 from maasserver.models import (
     Config,
     UserProfile,
@@ -112,8 +109,7 @@
     def test_settings_commissioning_POST(self):
         self.client_log_in(as_admin=True)
         new_check_compatibility = factory.getRandomBoolean()
-        new_commissioning_distro_series = factory.getRandomChoice(
-            COMMISSIONING_DISTRO_SERIES_CHOICES)
+        new_commissioning = factory.getRandomCommissioningRelease(DEFAULT_OS)
         response = self.client.post(
             reverse('settings'),
             get_prefixed_form_data(
@@ -121,14 +117,14 @@
                 data={
                     'check_compatibility': new_check_compatibility,
                     'commissioning_distro_series': (
-                        new_commissioning_distro_series),
+                        new_commissioning),
                 }))
 
         self.assertEqual(httplib.FOUND, response.status_code)
         self.assertEqual(
             (
                 new_check_compatibility,
-                new_commissioning_distro_series,
+                new_commissioning,
             ),
             (
                 Config.objects.get_config('check_compatibility'),
@@ -156,11 +152,38 @@
                 Config.objects.get_config('enable_third_party_drivers'),
             ))
 
+    def test_settings_deploy_POST(self):
+        self.client_log_in(as_admin=True)
+        new_osystem = factory.getRandomOS()
+        new_default_osystem = new_osystem.name
+        new_default_distro_series = factory.getRandomRelease(new_osystem)
+        response = self.client.post(
+            reverse('settings'),
+            get_prefixed_form_data(
+                prefix='deploy',
+                data={
+                    'default_osystem': new_default_osystem,
+                    'default_distro_series': '%s/%s' % (
+                        new_default_osystem,
+                        new_default_distro_series
+                        ),
+                }))
+
+        self.assertEqual(httplib.FOUND, response.status_code, response.content)
+        self.assertEqual(
+            (
+                new_default_osystem,
+                new_default_distro_series,
+            ),
+            (
+                Config.objects.get_config('default_osystem'),
+                Config.objects.get_config('default_distro_series'),
+            ))
+
     def test_settings_ubuntu_POST(self):
         self.client_log_in(as_admin=True)
         new_main_archive = 'http://test.example.com/archive'
         new_ports_archive = 'http://test2.example.com/archive'
-        new_default_distro_series = factory.getRandomEnum(DISTRO_SERIES)
         response = self.client.post(
             reverse('settings'),
             get_prefixed_form_data(
@@ -168,7 +191,6 @@
                 data={
                     'main_archive': new_main_archive,
                     'ports_archive': new_ports_archive,
-                    'default_distro_series': new_default_distro_series,
                 }))
 
         self.assertEqual(httplib.FOUND, response.status_code, response.content)
@@ -176,12 +198,10 @@
             (
                 new_main_archive,
                 new_ports_archive,
-                new_default_distro_series,
             ),
             (
                 Config.objects.get_config('main_archive'),
                 Config.objects.get_config('ports_archive'),
-                Config.objects.get_config('default_distro_series'),
             ))
 
     def test_settings_kernelopts_POST(self):

=== modified file 'src/metadataserver/tests/test_api.py'
--- src/metadataserver/tests/test_api.py	2014-03-24 13:02:28 +0000
+++ src/metadataserver/tests/test_api.py	2014-04-24 17:04:47 +0000
@@ -394,6 +394,7 @@
         node = factory.make_node()
         arch, subarch = node.architecture.split('/')
         factory.make_boot_image(
+            osystem=node.get_osystem(),
             architecture=arch, subarchitecture=subarch,
             release=node.get_distro_series(), purpose='xinstall',
             nodegroup=node.nodegroup)

=== modified file 'src/provisioningserver/boot/__init__.py'
--- src/provisioningserver/boot/__init__.py	2014-03-28 16:46:55 +0000
+++ src/provisioningserver/boot/__init__.py	2014-04-24 17:04:47 +0000
@@ -168,7 +168,7 @@
         """
         def image_dir(params):
             return compose_image_path(
-                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-03-28 04:31:32 +0000
+++ src/provisioningserver/boot/tests/test_pxe.py	2014-04-24 17:04:47 +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(
-            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)
@@ -268,7 +270,8 @@
             section = config[section_label]
             self.assertThat(
                 section, ContainsAll(("KERNEL", "INITRD", "APPEND")))
-            contains_arch_path = StartsWith("%s/" % section_label)
+            contains_arch_path = StartsWith(
+                "%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-03 09:26:31 +0000
+++ src/provisioningserver/boot/tests/test_tftppath.py	2014-04-24 17:04:47 +0000
@@ -30,6 +30,10 @@
     list_subdirs,
     locate_tftp_path,
     )
+from provisioningserver.osystems import (
+    OperatingSystem,
+    OperatingSystemRegistry,
+    )
 from provisioningserver.testing.boot_images import (
     make_boot_image_storage_params,
     )
@@ -51,6 +55,63 @@
     return image
 
 
+def make_osystem(osystem, purpose, testcase):
+    """Makes the operating system class and registers it."""
+    if osystem not in OperatingSystemRegistry:
+
+        class FakeOS(OperatingSystem):
+
+            name = osystem
+            title = osystem
+
+            def __init__(self, purpose, releases=None):
+                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
+                    ]
+
+        fake = FakeOS(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):
@@ -62,6 +123,7 @@
         """Fake a boot image matching `image_params` under `tftproot`."""
         image_dir = locate_tftp_path(
             compose_image_path(
+                osystem=image_params['osystem'],
                 arch=image_params['architecture'],
                 subarch=image_params['subarchitecture'],
                 release=image_params['release'],
@@ -72,21 +134,23 @@
         factory.make_file(image_dir, 'initrd.gz')
 
     def test_compose_image_path_follows_storage_directory_layout(self):
+        osystem = factory.make_name('osystem')
         arch = factory.make_name('arch')
         subarch = factory.make_name('subarch')
         release = factory.make_name('release')
         label = factory.make_name('label')
         self.assertEqual(
-            '%s/%s/%s/%s' % (arch, subarch, release, label),
-            compose_image_path(arch, subarch, release, label))
+            '%s/%s/%s/%s/%s' % (osystem, arch, subarch, release, label),
+            compose_image_path(osystem, arch, subarch, release, label))
 
     def test_compose_image_path_does_not_include_tftp_root(self):
+        osystem = factory.make_name('osystem')
         arch = factory.make_name('arch')
         subarch = factory.make_name('subarch')
         release = factory.make_name('release')
         label = factory.make_name('label')
         self.assertThat(
-            compose_image_path(arch, subarch, release, label),
+            compose_image_path(osystem, arch, subarch, release, label),
             Not(StartsWith(self.tftproot)))
 
     def test_locate_tftp_path_prefixes_tftp_root(self):
@@ -120,19 +184,22 @@
         params = make_boot_image_storage_params()
         self.make_image_dir(params, self.tftproot)
         purposes = ['install', 'commissioning', 'xinstall']
+        make_osystem(params['osystem'], purposes, self)
         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(param['osystem'], purposes, self)
         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))
 

=== modified file 'src/provisioningserver/boot/tests/test_uefi.py'
--- src/provisioningserver/boot/tests/test_uefi.py	2014-03-28 19:03:46 +0000
+++ src/provisioningserver/boot/tests/test_uefi.py	2014-04-24 17:04:47 +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(
-            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-03 16:36:15 +0000
+++ src/provisioningserver/boot/tftppath.py	2014-04-24 17:04:47 +0000
@@ -25,16 +25,21 @@
 from logging import getLogger
 import os.path
 
+from provisioningserver.osystems import (
+    OperatingSystemError,
+    OperatingSystemRegistry,
+    )
 
 logger = getLogger(__name__)
 
 
-def compose_image_path(arch, subarch, release, label):
+def compose_image_path(osystem, arch, subarch, release, label):
     """Compose the TFTP path for a PXE kernel/initrd directory.
 
     The path returned is relative to the TFTP root, as it would be
     identified by clients on the network.
 
+    :param osystem: Operating system.
     :param arch: Main machine architecture.
     :param subarch: Sub-architecture, or "generic" if there is none.
     :param release: Operating system release, e.g. "precise".
@@ -43,7 +48,7 @@
         kernel and initrd) as exposed over TFTP.
     """
     # This is a TFTP path, not a local filesystem path, so hard-code the slash.
-    return '/'.join([arch, subarch, release, label])
+    return '/'.join([osystem, arch, subarch, release, label])
 
 
 def locate_tftp_path(path, tftproot):
@@ -113,19 +118,20 @@
 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.
     """
-    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, arch, subarch, release, label = path
+    osystem_obj = OperatingSystemRegistry.get_item(osystem, default=None)
+    if osystem_obj is None:
+        raise OperatingSystemError(
+            "Unsupported operating system: %s" % osystem)
+
+    purposes = osystem_obj.get_boot_image_purposes(
+        arch, subarch, release, label)
     return [
         dict(
-            architecture=arch, subarchitecture=subarch,
+            osystem=osystem, architecture=arch, subarchitecture=subarch,
             release=release, label=label, purpose=purpose)
         for purpose in purposes
         ]
@@ -139,9 +145,9 @@
         `report_boot_images` API call.
     """
     # The sub-directories directly under tftproot, if they contain
-    # images, represent architectures.
+    # images, represent operating systems.
     try:
-        potential_archs = list_subdirs(tftproot)
+        potential_osystems = list_subdirs(tftproot)
     except OSError as exception:
         if exception.errno == errno.ENOENT:
             # Directory does not exist, so return empty list.
@@ -153,12 +159,12 @@
 
     # Starting point for iteration: paths that contain only the
     # top-level subdirectory of tftproot, i.e. the architecture name.
-    paths = [[subdir] for subdir in potential_archs]
+    paths = [[subdir] for subdir in potential_osystems]
 
     # Extend paths deeper into the filesystem, through the levels that
-    # represent sub-architecture, release, and label.  Any directory
-    # that doesn't extend this deep isn't a boot image.
-    for level in ['subarch', 'release', 'label']:
+    # represent architecture, sub-architecture, release, and label.
+    # Any directory that doesn't extend this deep isn't a boot image.
+    for level in ['arch', 'subarch', 'release', 'label']:
         paths = drill_down(tftproot, paths)
 
     # Each path we find this way should be a boot image.

=== modified file 'src/provisioningserver/import_images/boot_resources.py'
--- src/provisioningserver/import_images/boot_resources.py	2014-04-11 03:00:13 +0000
+++ src/provisioningserver/import_images/boot_resources.py	2014-04-24 17:04:47 +0000
@@ -80,7 +80,7 @@
     return reverse
 
 
-def tgt_entry(arch, subarch, release, label, image):
+def tgt_entry(osystem, arch, subarch, release, label, image):
     """Generate tgt target used to commission arch/subarch with release
 
     Tgt target used to commission arch/subarch machine with a specific Ubuntu
@@ -94,6 +94,7 @@
     use the same inode for different tgt targets (even read-only targets which
     looks like a bug to me) without this option enabled.
 
+    :param osystem: Operating System name we generate tgt target for
     :param arch: Architecture name we generate tgt target for
     :param subarch: Subarchitecture name we generate tgt target for
     :param release: Ubuntu release we generate tgt target for
@@ -102,7 +103,13 @@
     :return Tgt entry which can be written to tgt-admin configuration file
     """
     prefix = 'iqn.2004-05.com.ubuntu:maas'
-    target_name = 'ephemeral-%s-%s-%s-%s' % (arch, subarch, release, label)
+    target_name = 'ephemeral-%s-%s-%s-%s-%s' % (
+        osystem,
+        arch,
+        subarch,
+        release,
+        label
+        )
     entry = dedent("""\
         <target {prefix}:{target_name}>
             readonly 1
@@ -229,17 +236,20 @@
     # Use a set to make sure we don't register duplicate entries in tgt.
     entries = set()
     for item in list_boot_images(snapshot_path):
+        osystem = item['osystem']
         arch = item['architecture']
         subarch = item['subarchitecture']
         release = item['release']
         label = item['label']
-        entries.add((arch, subarch, release, label))
+        entries.add((osystem, arch, subarch, release, label))
     tgt_entries = []
-    for arch, subarch, release, label in sorted(entries):
+    for osystem, arch, subarch, release, label in sorted(entries):
         root_image = os.path.join(
-            snapshot_path, arch, subarch, release, label, 'root-image')
+            snapshot_path, osystem, arch, subarch,
+            release, label, 'root-image')
         if os.path.isfile(root_image):
-            entry = tgt_entry(arch, subarch, release, label, root_image)
+            entry = tgt_entry(
+                osystem, arch, subarch, release, label, root_image)
             tgt_entries.append(entry)
     text = ''.join(tgt_entries)
     return text.encode('utf-8')
@@ -319,7 +329,8 @@
     snapshot_path = compose_snapshot_path(storage)
     cache_path = os.path.join(storage, 'cache')
     targets_conf = os.path.join(snapshot_path, 'maas.tgt')
-    writer = RepoWriter(snapshot_path, cache_path, reverse_boot)
+    ubuntu_path = os.path.join(snapshot_path, 'ubuntu')
+    writer = RepoWriter(ubuntu_path, cache_path, reverse_boot)
 
     for source in sources:
         writer.write(source['path'], source['keyring'])

=== modified file 'src/provisioningserver/import_images/tests/test_boot_resources.py'
--- src/provisioningserver/import_images/tests/test_boot_resources.py	2014-04-11 02:58:32 +0000
+++ src/provisioningserver/import_images/tests/test_boot_resources.py	2014-04-24 17:04:47 +0000
@@ -101,9 +101,10 @@
 
     def test_generates_one_target(self):
         spec = make_image_spec()
+        osystem = factory.make_name('osystem')
         image = self.make_file()
         entry = boot_resources.tgt_entry(
-            spec.arch, spec.subarch, spec.release, spec.label, image)
+            osystem, spec.arch, spec.subarch, spec.release, spec.label, image)
         # The entry looks a bit like XML, but isn't well-formed.  So don't try
         # to parse it as such!
         self.assertIn('<target iqn.2004-05.com.ubuntu:maas:', entry)
@@ -113,8 +114,9 @@
     def test_produces_suitable_output_for_tgt_admin(self):
         spec = make_image_spec()
         image = self.make_file()
+        osystem = factory.make_name('osystem')
         entry = boot_resources.tgt_entry(
-            spec.arch, spec.subarch, spec.release, spec.label, image)
+            osystem, spec.arch, spec.subarch, spec.release, spec.label, image)
         config = self.make_file(contents=entry)
         # Pretend to be root, but without requiring the actual privileges and
         # without prompting for a password.  In that state, run tgt-admin.
@@ -326,7 +328,7 @@
         self.assertThat(os.path.join(current, 'maas.meta'), FileExists())
         self.assertThat(os.path.join(current, 'maas.tgt'), FileExists())
         self.assertThat(
-            os.path.join(current, arch, subarch, release, label),
+            os.path.join(current, 'ubuntu', arch, subarch, release, label),
             DirExists())
 
         # Verify the contents of the "meta" file.

=== modified file 'src/provisioningserver/kernel_opts.py'
--- src/provisioningserver/kernel_opts.py	2014-03-20 10:44:56 +0000
+++ src/provisioningserver/kernel_opts.py	2014-04-24 17:04:47 +0000
@@ -30,9 +30,10 @@
 
 KernelParametersBase = namedtuple(
     "KernelParametersBase", (
+        "osystem",  # Operating system, e.g. "ubuntu"
         "arch",  # Machine architecture, e.g. "i386"
         "subarch",  # Machine subarchitecture, e.g. "generic"
-        "release",  # Ubuntu release, e.g. "precise"
+        "release",  # OS release, e.g. "precise"
         "label",  # Image label, e.g. "release"
         "purpose",  # Boot purpose, e.g. "commissioning"
         "hostname",  # Machine hostname, e.g. "coleman"
@@ -90,9 +91,15 @@
 ISCSI_TARGET_NAME_PREFIX = "iqn.2004-05.com.ubuntu:maas"
 
 
-def get_ephemeral_name(arch, subarch, release, label):
+def get_ephemeral_name(osystem, arch, subarch, release, label):
     """Return the name of the most recent ephemeral image."""
-    return "ephemeral-%s-%s-%s-%s" % (arch, subarch, release, label)
+    return "ephemeral-%s-%s-%s-%s-%s" % (
+        osystem,
+        arch,
+        subarch,
+        release,
+        label
+        )
 
 
 def compose_hostname_opts(params):
@@ -119,7 +126,8 @@
         # These are kernel parameters read by the ephemeral environment.
         tname = prefix_target_name(
             get_ephemeral_name(
-                params.arch, params.subarch, params.release, params.label))
+                params.osystem, params.arch, params.subarch,
+                params.release, params.label))
         kernel_params = [
             # Read by the open-iscsi initramfs code.
             "iscsi_target_name=%s" % tname,

=== added directory 'src/provisioningserver/osystems'
=== added file 'src/provisioningserver/osystems/__init__.py'
--- src/provisioningserver/osystems/__init__.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/osystems/__init__.py	2014-04-24 17:04:47 +0000
@@ -0,0 +1,103 @@
+# Copyright 2014 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Provides the support for Operating Systems."""
+
+from __future__ import (
+    absolute_import,
+    print_function,
+    unicode_literals,
+    )
+
+str = None
+
+__metaclass__ = type
+__all__ = [
+    "OperatingSystem",
+    "OperatingSystemRegistry",
+    ]
+
+from abc import (
+    ABCMeta,
+    abstractmethod,
+    abstractproperty,
+    )
+
+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 OperatingSystemError(Exception):
+    """Exception raised for errors from a OperatingSystem."""
+
+
+class OperatingSystem:
+    """Skeleton for a 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 OperatingSystemRegistry(Registry):
+    """Registry for operating system classes."""
+
+
+# Import the supported operating systems after defining OperatingSystem.
+from provisioningserver.osystems.ubuntu import UbuntuOS
+
+
+builtin_ossytems = [
+    UbuntuOS(),
+]
+for osystem in builtin_ossytems:
+    OperatingSystemRegistry.register_item(osystem.name, osystem)

=== added directory 'src/provisioningserver/osystems/tests'
=== added file 'src/provisioningserver/osystems/tests/__init__.py'
=== added file 'src/provisioningserver/osystems/tests/test_ubuntu.py'
--- src/provisioningserver/osystems/tests/test_ubuntu.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/osystems/tests/test_ubuntu.py	2014-04-24 17:04:47 +0000
@@ -0,0 +1,31 @@
+# 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 maastesting.testcase import MAASTestCase
+from provisioningserver.osystems.ubuntu import (
+    DISTRO_SERIES_CHOICES,
+    UbuntuOS,
+    )
+
+
+class TestUbuntuOS(MAASTestCase):
+
+    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)

=== added file 'src/provisioningserver/osystems/ubuntu.py'
--- src/provisioningserver/osystems/ubuntu.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/osystems/ubuntu.py	2014-04-24 17:04:47 +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.osystems 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

=== modified file 'src/provisioningserver/rpc/cluster.py'
--- src/provisioningserver/rpc/cluster.py	2014-03-20 22:36:32 +0000
+++ src/provisioningserver/rpc/cluster.py	2014-04-24 17:04:47 +0000
@@ -33,7 +33,8 @@
     arguments = []
     response = [
         (b"images", amp.AmpList(
-            [(b"architecture", amp.Unicode()),
+            [(b"osystem", amp.Unicode()),
+             (b"architecture", amp.Unicode()),
              (b"subarchitecture", amp.Unicode()),
              (b"release", amp.Unicode()),
              (b"label", amp.Unicode()),

=== modified file 'src/provisioningserver/rpc/tests/test_clusterservice.py'
--- src/provisioningserver/rpc/tests/test_clusterservice.py	2014-03-28 04:31:32 +0000
+++ src/provisioningserver/rpc/tests/test_clusterservice.py	2014-04-24 17:04:47 +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,
@@ -171,6 +172,7 @@
         # serialised correctly.
 
         # Example boot image definitions.
+        osystems = "ubuntu", "centos"
         archs = "i386", "amd64"
         subarchs = "generic", "special"
         releases = "precise", "trusty"
@@ -179,22 +181,24 @@
 
         # Create a TFTP file tree with a variety of subdirectories.
         tftpdir = self.make_dir()
-        for options in product(archs, subarchs, releases, labels):
+        for options in product(osystems, archs, subarchs, releases, labels):
             os.makedirs(os.path.join(tftpdir, *options))
+            make_osystem(options[0], purposes, self)
 
         # Ensure that list_boot_images() uses the above TFTP file tree.
         self.useFixture(set_tftp_root(tftpdir))
 
         expected_images = [
             {
+                "osystem": osystem,
                 "architecture": arch,
                 "subarchitecture": subarch,
                 "release": release,
                 "label": label,
                 "purpose": purpose,
             }
-            for arch, subarch, release, label, purpose in product(
-                archs, subarchs, releases, labels, purposes)
+            for osystem, arch, subarch, release, label, purpose in product(
+                osystems, archs, subarchs, releases, labels, purposes)
             ]
 
         response = yield call_responder(Cluster(), cluster.ListBootImages, {})

=== modified file 'src/provisioningserver/testing/boot_images.py'
--- src/provisioningserver/testing/boot_images.py	2014-03-21 03:21:57 +0000
+++ src/provisioningserver/testing/boot_images.py	2014-04-24 17:04:47 +0000
@@ -23,10 +23,11 @@
     """Create an arbitrary dict of boot-image parameters.
 
     These are the parameters that together describe a kind of boot for
-    which we may need a kernel and initrd: architecture,
+    which we may need a kernel and initrd: operating system, architecture,
     sub-architecture, Ubuntu release, boot purpose, and release label.
     """
     return dict(
+        osystem=factory.make_name('osystem'),
         architecture=factory.make_name('architecture'),
         subarchitecture=factory.make_name('subarchitecture'),
         release=factory.make_name('release'),
@@ -39,9 +40,11 @@
     """Create a dict of boot-image parameters as used to store the image.
 
     These are the parameters that together describe a path to store a boot
-    image: architecture, sub-architecture, Ubuntu release, and release label.
+    image: operating system, architecture, sub-architecture, Ubuntu release,
+    and release label.
     """
     return dict(
+        osystem=factory.make_name('osystem'),
         architecture=factory.make_name('architecture'),
         subarchitecture=factory.make_name('subarchitecture'),
         release=factory.make_name('release'),

=== modified file 'src/provisioningserver/tests/test_kernel_opts.py'
--- src/provisioningserver/tests/test_kernel_opts.py	2014-03-28 16:46:55 +0000
+++ src/provisioningserver/tests/test_kernel_opts.py	2014-04-24 17:04:47 +0000
@@ -228,7 +228,8 @@
         # options for a "xinstall" node.
         params = self.make_kernel_parameters(purpose="xinstall")
         ephemeral_name = get_ephemeral_name(
-            params.arch, params.subarch, params.release, params.label)
+            params.osystem, params.arch, params.subarch,
+            params.release, params.label)
         self.assertThat(
             compose_kernel_command_line(params),
             ContainsAll([
@@ -243,7 +244,8 @@
         # options for a "commissioning" node.
         params = self.make_kernel_parameters(purpose="commissioning")
         ephemeral_name = get_ephemeral_name(
-            params.arch, params.subarch, params.release, params.label)
+            params.osystem, params.arch, params.subarch,
+            params.release, params.label)
         self.assertThat(
             compose_kernel_command_line(params),
             ContainsAll([