Merge lp:~blake-rouse/maas/add-osystem-to-node-form-api into lp:~maas-committers/maas/trunk

[Blake Rouse]

Add operating system selection to NodeForm, and os selection from distro series in start api call.

This replaces the large merge of add-osystem-to-node, and separates it into 3 different mergers. This is the second one.

The start node API uses the same distro_series options so that the api call does not change. The osystem is selected based on the operating system that is found to contain that distro_series/release. The valid choices that get displayed in the WebUI are based on the BootImage's that are available, removing the ability for a user to select an operating system and release combination that would not boot.

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

[Jason Hobbs (jason-hobbs)]

I am new to a lot of this part of MAAS and as a result, this review is probably more of the trees than of the forest. Over all it looks good to me, but I do have some questions and comments.

[1] Needs make format/make lint.

[2]

@@ -403,7 +407,7 @@
             available to the nodes through the metadata service.
         :type user_data: base64-encoded unicode
         :param distro_series: If present, this parameter specifies the
- Ubuntu Release the node will use.
+ os relase the node will use.

Typo 'relase'. Maybe s/os/OS too.

[3]

-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
@@ -2364,7 +2368,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"

Why isn't this error state handled when we configure the node? It is
confusing to have a node configured for xinstall, but to have it really
use install behind the scenes.

[4]
+ # 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)

Same comment as [3].

Also, don't need the comma between 'label' and 'here'.

[5]
     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)

Same comment as [3] again - didn't need to grab purpose more than once
with the previous implementation.

Also, s/lets/let's and drop comma between 'label' and 'is'.

=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py 2014-05-14 07:12:10 +0000
+++ src/maasserver/forms.py 2014-05-14 14:40:00 +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_commisioni...

review: Needs Information

[Blake Rouse (blake-rouse)]

[1,2] Fixed

[3] Why fail a node from working? What is the downside of using install instead of xinstall, you still end up with a system that is similar after finish installation, its just speed. So if the operating system installs using fast-path great, if not then use the old way. Also since fast-path booting is only set by a tag, then it makes it even harder to catch. As you wouldn't see the error until you go to turn on the node, at which case it has already been acquired and it will fail, causing JuJu to fail.

[4,5] Comments fixed.
[5] You need to grab the purpose first only because the boot label is unknown on the first call. So first it gets the purpose without the label, then once the correct label is select. Just to check the label supports that purpose we call again. Its just a good check to make sure that the final selected boot image can handle this method.

[6] Early out used!
[6] It needs to handle two form inputs as the OS selection is used with NodeForm, and DeployForm. Didn't want to duplicate the code, when it would be the same so I split it out into a method that can handle multiple forms.

[7,8] Fixed

[9] Merge conflict resolved

[10] Its always a good check to make sure that it is not None, so I check. It really would only be a blank string, but doesn't hurt to just make sure. Being explicit.

[11] Split into two tests.

[12] This is testing that the set method is actually still being called. So if the code was to change where it wasn't this would break the API and the test would fail.

[13] This actually uses a different method on Node, release. The release call resets the osystem and distro_series. Also a good check to make sure that the release call is called.

[14] Belief that it makes it easier to see that the test is testing it multiple times.

[15] Differ in one tests that the items are there, and the other tests that the items are sorted. This is a copy of how the architecture code is tested.

[16]
Added test for maasserver.api.get_boot_purpose() on return "install" when os doesn't support "xinstall".

NodeForm.set_up_osystem_and_distro_series_fields() and maasserver.forms.clean_distro_series_field() is being tested in maasserver.tests.test_forms.TestNodeForm by the following:
  - test_contains_limited_set_of_fields
  - test_accepts_osystem
  - test_rejects_invalid_osystem
  - test_starts_with_default_osystem
  - test_accepts_osystem_distro_series
  - test_rejects_invalid_osystem_distro_series
  - test_starts_with_default_distro_series
  - test_rejects_mismatch_osystem_distro_series

maasserver.models.node.validate_osystem() and maasserver.models.node.validate_distro_series() are getting tested with the TestNodeForm and the start API call.

These are getting covered by the usage of the forms, views, and api throughout the testing code base, as you stated.
  - maasserver.forms.list_release_choices()
  - maasserver.forms.list_osystem_choices()
  - NodeForm.clean_distro_series()
  - maasserver.form_settings.list_osystem_choices()
  - maasserver.form_settings.list_release_choices()
  - maasserver.form_settings.list_commissioning_choices()
  - maasserver.models.node.get_all_releases()
  - maasserver.models.node.get_o...

[Jason Hobbs (jason-hobbs)]

Thanks! A couple more comments inline below.

On Thu, May 15, 2014 at 4:22 PM, Blake Rouse <email address hidden>wrote:
>
> [3] Why fail a node from working?

I don't mean that we should fail the node instead of reverting to install,
but that we should never be able to get a Node into the state where it's
configured to xinstall with an OS that can't xinstall. Ideally we would
raise a validation error whenever someone configured a node to xinstall
with an OS/release that couldn't xinstall. Maybe it's harder than it should
be because we use a tag to indicate xinstall use.

> What is the downside of using install instead of xinstall, you still end
> up with a system that is similar after finish installation, its just speed.

What if you have a modified preseed or pxeconfig for xinstall, with stuff
that's critical in it? Or a feature that is enabled for xinstall but not
install (which will likely happen with debian-installer being deprecated).
It seems fragile to assume that they are now and will forever be equivalent
other than speed.

>
> [7,8] Fixed
>

You may want to double check the new validate_osystem() - I think you need
to invert your logic for using the early out way. If it's passing tests as
is I would also double check those :).

>
> [9] Merge conflict resolved
>
> [10] Its always a good check to make sure that it is not None, so I check.
> It really would only be a blank string, but doesn't hurt to just make sure.
> Being explicit.
>
> [11] Split into two tests.
>
> [12] This is testing that the set method is actually still being called.
> So if the code was to change where it wasn't this would break the API and
> the test would fail.
>
> [13] This actually uses a different method on Node, release. The release
> call resets the osystem and distro_series. Also a good check to make sure
> that the release call is called.
>
> [14] Belief that it makes it easier to see that the test is testing it
> multiple times.
>
> [15] Differ in one tests that the items are there, and the other tests
> that the items are sorted. This is a copy of how the architecture code is
> tested.
>

Yes, the difference just makes them more fun to refactor though :).

Jason

[Jason Hobbs (jason-hobbs)]

review: Approve

[Blake Rouse (blake-rouse)]

Nice catch, validate_osystem was incorrect and was not being tested for a bad value. Added a test for bad value for validate_osystem and validate_distro_series.

[Jeroen T. Vermeulen (jtv)]

I'm going to review this in detail, but time has run out for me today; I'll have to get back to it tomorrow. Smaller branches have less of this problem!

For the record, I agree with Jason that it's better to fail early than tohide potentially problematic settings. But of course that's assuming that we can reasonably catch the problem at the right stage. Once we're trying to boot a node, it's probably too late.

As for the get_boot_purpose call where the label is None, I'd suggest passing it as a keyword for clarity: label=None.

[Jeroen T. Vermeulen (jtv)]

Damn those big branches! It's good, but far too big. I'm attaching inline review notes for the first 500 lines or so, up to (but not including) src/maasserver/models/node.py. More tomorrow...

[Jeroen T. Vermeulen (jtv)]

I just reviewed src/maasserver/models/node.py as well (again using inline comments) and I hit one sticking point: I don't think validation of a node's operating system and release against the database belongs on the model. The model can validate for basic sanity of the input string, but I feel the checks for supported systems/releases belongs at the form level.

If these were proper foreign keys then yes, clearly it's a model integrity issue. But then we'd also have model-level protection against osystems being deleted while nodes still refer to them. We would have the full stack of referential-integrity mechanisms to do the work for us, efficiently and reliably. But where possible I would avoid model validation that needs to query the database.

As it is, don't these validators break tests? I would expect factory.make_node to set a random operating system and release, and unless you surprised the caller by also creating boot images (probably breaking other tests), the validators would wreak havoc on the test suite.

[Blake Rouse (blake-rouse)]

osystem has validation in the model, as this field can also be set with the start API call. distro_series always had validation using the choices=, but now its just using a function to perform the validation. It gives the same result.

factory.make_node does not break tests, as the osystem field just like the distro_series field was can be blank. If the field is blank then the default is used, so no tests break.

[Jeroen T. Vermeulen (jtv)]

One of our architecture decisions is that the API should validate through the forms, so validating in the form should also cover the API.

We normally like our factories to produce randomised fields, not reliable blanks. (If a field can be blank, it can be useful to flip a coin first — heads, leave blank; tails, make up random value.)

[Blake Rouse (blake-rouse)]

I was just implementing it the exact way it was implemented before, I just
added a new field osystem. If you would like me to implement it
differently, then I can. Let me know what you would like me to do. I can do
this in a later branch, as this one long enough. :)

On Thu, May 22, 2014 at 10:15 AM, Jeroen T. Vermeulen <email address hidden>wrote:

> One of our architecture decisions is that the API should validate through
> the forms, so validating in the form should also cover the API.
>
> We normally like our factories to produce randomised fields, not reliable
> blanks. (If a field can be blank, it can be useful to flip a coin first —
> heads, leave blank; tails, make up random value.)
> --
>
> https://code.launchpad.net/~blake-rouse/maas/add-osystem-to-node-form-api/+merge/219521
> You are the owner of lp:~blake-rouse/maas/add-osystem-to-node-form-api.
>

[Raphaël Badin (rvb)]

My general take on how validation should be performed is that we should use model-level validation only to avoid inconsistencies in the DB. The rest of the validation belongs to forms. They give us a much more flexible way to validate the input from the UI and the API. More flexible because we can still manipulate objects directly in tests and migrations. This is just a matter of properly separating the M and the C (in MVC) because they are fundamentally separate steps; mingling them together reduces the flexibility of the whole model.

> osystem has validation in the model, as this field can also be set with the start API call.
> distro_series always had validation using the choices=, but now its just using a function to
> perform the validation. It gives the same result.

The result is not quite the same, no. Doing this kind of application-level integrity enforcement at the model level reduces our ability to deal gracefully with inconsistencies. Consider for instance the consequence of having an OS removed: one would be incapable of modifying the nodes referencing this OS unless he also changes the OS (because the validation would fail at the model level); if the validation happens at the form level, at least we could write a migration to deal with these nodes.

> factory.make_node does not break tests, as the osystem field just like the distro_series
> field was can be blank. If the field is blank then the default is used, so no tests break.

But then all your tests operate with a very special case (osystem=blank). It's much better to have the tests operate on data that is as similar to production data as possible. This is also why we chose to use randomness when creating test objects.

[Blake Rouse (blake-rouse)]

> My general take on how validation should be performed is that we should use

> The result is not quite the same, no. Doing this kind of application-level
> integrity enforcement at the model level reduces our ability to deal
> gracefully with inconsistencies. Consider for instance the consequence of
> having an OS removed: one would be incapable of modifying the nodes
> referencing this OS unless he also changes the OS (because the validation
> would fail at the model level); if the validation happens at the form level,
> at least we could write a migration to deal with these nodes.

This makes since, it would fail to save the node if an os was removed. I will refactor the code to remove the validation from the model.

> But then all your tests operate with a very special case (osystem=blank).
> It's much better to have the tests operate on data that is as similar to
> production data as possible. This is also why we chose to use randomness when
> creating test objects.

That is not a special case, it is the default case for all created nodes. Even nodes created by the user, use that value. Its the same implementation that was there for distro_series. If there was no issue the way it was before, why is there now?

[Raphaël Badin (rvb)]

> Its the same implementation that was there for distro_series.
> If there was no issue the way it was before, why is there now?

The `distro_series` stuff was implemented when the possible choices where not the dynamic object it is now. One could argue that even at that time it was a mistake but the point is that we shouldn't persist doing things the way `distro_series` was implemented for the many reasons stated above. This means that, ideally, we should also perform the validation for `distro_series` at the form level.

[Blake Rouse (blake-rouse)]

> The `distro_series` stuff was implemented when the possible choices where not
> the dynamic object it is now. One could argue that even at that time it was a
> mistake but the point is that we shouldn't persist doing things the way
> `distro_series` was implemented for the many reasons stated above. This means
> that, ideally, we should also perform the validation for `distro_series` at
> the form level.

Sorry I was talking specifically about factory.make_node. I will refactor distro_series and osystem to use form validation.

[Blake Rouse (blake-rouse)]

Removed the validation of osystem and distro_series from the NodeModel. The start API now uses the NodeForm to set the distro_series and osystem.

[Jeroen T. Vermeulen (jtv)]

I'm supposed to be reviewing the review here, I think, but things got so big that I just went back to the code! Anyway, thanks for doing this and for bearing with us when we made you jump through the additional hoops...

Notes about superficialities follow.

.

Doesn't that last line in list_commisioning_choices just return "options" as it already was? If you're trying to force eager evaluation, you could just return list(options).

.

In test_get_osystem_returns_default_osystem, you create a Node and assume that it won't have its osystem set. I think it would make sense to set a random one by default, in which case it would make more sense to set it to '' explicitly. (Yes, Django's handling of blank strings can be infuriating.) Same for test_get_distro_series_returns_default_series just below that.

.

In make_osystem_with_releases, and make_usable_osystem below that, I guess the “purpose” parameter should really be called “purposes” (plural).

.

Nice tests for list_all_usable_osystems, list_all_usable_releases, and the new form validation! Very focused, clearly named, distinct setup / execution / verification phases.

.

It'd be nice to rename _all_ mention of “series” to “releases”... maybe someday.

review: Approve

=== modified file 'src/maasserver/api.py'
--- src/maasserver/api.py	2014-05-27 15:05:37 +0000
+++ src/maasserver/api.py	2014-05-29 17:03:44 +0000
@@ -253,6 +253,10 @@
 from piston.emitters import JSONEmitter
 from piston.handler import typemapper
 from piston.utils import rc
+from provisioningserver.driver import (
+    BOOT_IMAGE_PURPOSE,
+    OperatingSystemRegistry,
+    )
 from provisioningserver.kernel_opts import KernelParameters
 from provisioningserver.power_schema import UNKNOWN_POWER_TYPE
 import simplejson as json
@@ -411,7 +415,7 @@
             available to the nodes through the metadata service.
         :type user_data: base64-encoded unicode
         :param distro_series: If present, this parameter specifies the
-            Ubuntu Release the node will use.
+            OS release the node will use.
         :type distro_series: unicode
 
         Ideally we'd have MIME multipart and content-transfer-encoding etc.
@@ -427,7 +431,13 @@
             node = Node.objects.get_node_or_404(
                 system_id=system_id, user=request.user,
                 perm=NODE_PERMISSION.EDIT)
-            node.set_distro_series(series=series)
+            Form = get_node_edit_form(request.user)
+            form = Form(instance=node)
+            form.set_distro_series(series=series)
+            if form.is_valid():
+                form.save()
+            else:
+                raise ValidationError(form.errors)
         nodes = Node.objects.start_nodes(
             [system_id], request.user, user_data=user_data)
         if len(nodes) == 0:
@@ -2369,7 +2379,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
@@ -2389,7 +2399,14 @@
             if node.should_use_traditional_installer():
                 return "install"
             else:
-                return "xinstall"
+                # Return normal install if the booting operating system
+                # doesn't support xinstall.
+                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:
@@ -2457,12 +2474,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)
@@ -2488,7 +2505,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, 'ubuntu', series, purpose=purpose)
+                    nodegroup, osystem, series, purpose='commissioning')
                 if image is None:
                     arch = 'i386'
                 else:
@@ -2496,12 +2513,16 @@
 
         subarch = get_optional_param(request.GET, 'subarch', 'generic')
 
+    # Get the purpose, without a selected label
+    purpose = get_boot_purpose(
+        node, osystem, arch, subarch, series, label=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, 'ubuntu', 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
@@ -2519,6 +2540,9 @@
         subarch = latest_image.subarchitecture
     label = get_optional_param(request.GET, 'label', latest_label)
 
+    # Get the supported purpose with the boot label
+    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
@@ -2548,7 +2572,7 @@
     cluster_address = get_mandatory_param(request.GET, "local")
 
     params = KernelParameters(
-        osystem='ubuntu', arch=arch, subarch=subarch, release=series,
+        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)
 
=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py	2014-05-26 14:14:57 +0000
+++ src/maasserver/forms.py	2014-05-29 17:03:44 +0000
@@ -73,9 +73,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,
@@ -88,8 +85,8 @@
 from maasserver.forms_settings import (
     CONFIG_ITEMS_KEYS,
     get_config_field,
-    INVALID_DISTRO_SERIES_MESSAGE,
     INVALID_SETTING_MSG_TEMPLATE,
+    list_commisioning_choices,
     )
 from maasserver.models import (
     BootImage,
@@ -117,6 +114,7 @@
 from maasserver.utils.network import make_network
 from metadataserver.fields import Bin
 from metadataserver.models import CommissioningScript
+from provisioningserver.driver import OperatingSystemRegistry
 
 # A reusable null-option for choice fields.
 BLANK_CHOICE = ('', '-------')
@@ -217,6 +215,106 @@
         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
+            ]
+    return choices
+
+
+def get_distro_series_inital(instance):
+    """Returns the distro_series initial value for the instance."""
+    osystem = instance.osystem
+    series = instance.distro_series
+    if osystem is not None and osystem != '':
+        if series is None:
+            series = ''
+        return '%s/%s' % (osystem, series)
+    return None
+
+
+def clean_distro_series_field(form, field, os_field):
+    """Cleans the distro_series field in the form. Validating that
+    the selected operating system matches the distro_series.
+
+    :param form: `Form` class
+    :param field: distro_series field name
+    :param os_field: osystem field name
+    :returns: clean distro_series field value
+    """
+    new_distro_series = form.cleaned_data.get(field)
+    if new_distro_series is None or '/' not in new_distro_series:
+        return new_distro_series
+    os, release = new_distro_series.split('/', 1)
+    if os_field in form.cleaned_data:
+        new_os = form.cleaned_data[os_field]
+        if os != new_os:
+            raise ValidationError(
+                "%s in %s does not match with "
+                "operating system %s" % (release, field, os))
+    return release
+
+
+def get_osystem_from_release(release):
+    """Returns the operating system that supports that release."""
+    for _, osystem in OperatingSystemRegistry:
+        if release in osystem.get_supported_releases():
+            return osystem
+    return None
+
+
 class NodeForm(ModelForm):
 
     def __init__(self, request=None, *args, **kwargs):
@@ -229,6 +327,7 @@
             self.fields['nodegroup'] = NodeGroupFormField(
                 required=False, empty_label="Default (master)")
         self.set_up_architecture_field()
+        self.set_up_osystem_and_distro_series_fields(kwargs.get('instance'))
 
     def set_up_architecture_field(self):
         """Create the `architecture` field.
@@ -248,6 +347,32 @@
             choices=choices, required=True, initial=default_arch,
             error_messages={'invalid_choice': invalid_arch_message})
 
+    def set_up_osystem_and_distro_series_fields(self, instance):
+        """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)
+        os_choices = list_osystem_choices(osystems)
+        distro_choices = list_release_choices(releases)
+        invalid_osystem_message = compose_invalid_choice_text(
+            'osystem', os_choices)
+        invalid_distro_series_message = compose_invalid_choice_text(
+            'distro_series', distro_choices)
+        self.fields['osystem'] = forms.ChoiceField(
+            label="OS", choices=os_choices, required=False, initial='',
+            error_messages={'invalid_choice': invalid_osystem_message})
+        self.fields['distro_series'] = forms.ChoiceField(
+            label="Release", choices=distro_choices,
+            required=False, initial='',
+            error_messages={'invalid_choice': invalid_distro_series_message})
+        if instance is not None:
+            initial_value = get_distro_series_inital(instance)
+            if instance is not None:
+                self.initial['distro_series'] = initial_value
+
     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
@@ -261,6 +386,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:
@@ -269,11 +397,24 @@
             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})
+    def set_distro_series(self, series=''):
+        """Sets the osystem and distro_series, from the provided
+        distro_series.
+        """
+        # This implementation is used so that current API, is not broken. This
+        # makes the distro_series a flat namespace. The distro_series is used
+        # to search through the supporting operating systems, to find the
+        # correct operating system that supports this distro_series.
+        self.is_bound = True
+        self.data['osystem'] = ''
+        self.data['distro_series'] = ''
+        if series is not None and series != '':
+            osystem = get_osystem_from_release(series)
+            if osystem is not None:
+                self.data['osystem'] = osystem.name
+                self.data['distro_series'] = '%s/%s' % (osystem.name, series)
+            else:
+                self.data['distro_series'] = series
 
     hostname = forms.CharField(
         label="Host name", required=False, help_text=(
@@ -292,6 +433,7 @@
         fields = (
             'hostname',
             'architecture',
+            'osystem',
             'distro_series',
             )
 
@@ -872,16 +1014,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-05-29 17:03:44 +0000
@@ -23,19 +23,41 @@
 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.driver 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():
+    osystems = [osystem for _, osystem in OperatingSystemRegistry]
+    osystems = sorted(osystems, key=lambda osystem: osystem.title)
+    return [
+        (osystem.name, osystem.title)
+        for osystem in osystems
+        ]
+
+
+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 list(options)
 
 
 CONFIG_ITEMS = {
@@ -139,28 +161,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': {
 
=== 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-05-29 17:03:44 +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.driver.os_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-05-27 07:11:28 +0000
+++ src/maasserver/models/node.py	2014-05-29 17:03:44 +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.driver import OperatingSystemRegistry
 from provisioningserver.tasks import (
     power_off,
     power_on,
@@ -486,7 +485,7 @@
         max_length=20, blank=True, default='')
 
     distro_series = CharField(
-        max_length=20, choices=DISTRO_SERIES_CHOICES, blank=True, default='')
+        max_length=20, blank=True, default='')
 
     architecture = CharField(max_length=31, blank=False)
 
@@ -793,21 +792,30 @@
         """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 = (self.osystem is None 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 = (
+            self.osystem is None 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 is None or
+            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_distro_series(self, series=''):
-        """Set the distro series to install that node."""
-        self.distro_series = series
-        self.save()
-
     def get_effective_power_parameters(self):
         """Return effective power parameters, including any defaults."""
         if self.power_parameters:
@@ -860,6 +868,7 @@
         self.token = None
         self.agent_name = ''
         self.set_netboot()
+        self.osystem = ''
         self.distro_series = ''
         self.save()
 
 
=== modified file 'src/maasserver/models/tests/test_node.py'
--- src/maasserver/models/tests/test_node.py	2014-05-27 12:35:35 +0000
+++ src/maasserver/models/tests/test_node.py	2014-05-29 17:03:44 +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,15 +269,14 @@
             offset += timedelta(1)
         self.assertEqual(macs[0], node.get_primary_mac().mac_address)
 
+    def test_get_osystem_returns_default_osystem(self):
+        node = factory.make_node(osystem='')
+        osystem = Config.objects.get_config('default_osystem')
+        self.assertEqual(osystem, node.get_osystem())
+
     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_set_get_distro_series_returns_series(self):
-        node = factory.make_node()
-        series = DISTRO_SERIES.quantal
-        node.set_distro_series(series)
+        node = factory.make_node(distro_series='')
+        series = Config.objects.get_config('default_distro_series')
         self.assertEqual(series, node.get_distro_series())
 
     def test_delete_node_deletes_related_mac(self):
@@ -597,11 +595,15 @@
         node.release()
         self.assertTrue(node.netboot)
 
-    def test_release_clears_distro_series(self):
+    def test_release_clears_osystem_and_distro_series(self):
         node = factory.make_node(
             status=NODE_STATUS.ALLOCATED, owner=factory.make_user())
-        node.set_distro_series(series=DISTRO_SERIES.quantal)
+        osystem = factory.getRandomOS()
+        release = factory.getRandomRelease(osystem)
+        node.osystem = osystem.name
+        node.distro_series = release
         node.release()
+        self.assertEqual("", node.osystem)
         self.assertEqual("", node.distro_series)
 
     def test_release_powers_off_node(self):
 
=== modified file 'src/maasserver/preseed.py'
--- src/maasserver/preseed.py	2014-04-23 16:09:39 +0000
+++ src/maasserver/preseed.py	2014-05-29 17:03:44 +0000
@@ -93,7 +93,7 @@
 
 def get_curtin_installer_url(node):
     """Return the URL where curtin on the node can download its installer."""
-    osystem = 'ubuntu'
+    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
 
=== modified file 'src/maasserver/testing/osystems.py'
--- src/maasserver/testing/osystems.py	2014-05-14 15:12:48 +0000
+++ src/maasserver/testing/osystems.py	2014-05-29 17:03:44 +0000
@@ -25,23 +25,27 @@
 from provisioningserver.driver import BOOT_IMAGE_PURPOSE
 
 
-def make_osystem_with_releases(testcase, osystem_name=None, releases=None):
+def make_osystem_with_releases(testcase, osystem_name=None, releases=None,
+                               purposes=None):
     """Generate an arbitrary operating system.
 
     :param osystem_name: The operating system name. Useful in cases where
         we need to test that not supplying an os works correctly.
     :param releases: The list of releases name. Useful in cases where
         we need to test that not supplying a release works correctly.
+    :param purposes: The purpose's of the boot images.
     """
     if osystem_name is None:
         osystem_name = factory.make_name('os')
     if releases is None:
         releases = [factory.make_name('release') for _ in range(3)]
+    if purposes is None:
+        purposes = [BOOT_IMAGE_PURPOSE.INSTALL, BOOT_IMAGE_PURPOSE.XINSTALL]
 
     osystem = make_osystem(
         testcase,
         osystem_name,
-        [BOOT_IMAGE_PURPOSE.INSTALL, BOOT_IMAGE_PURPOSE.XINSTALL])
+        purposes)
     if releases is not None and releases != []:
         osystem.fake_list = releases
     return osystem
@@ -72,7 +76,8 @@
         forms, 'list_all_usable_releases').return_value = distro_series
 
 
-def make_usable_osystem(testcase, osystem_name=None, releases=None):
+def make_usable_osystem(testcase, osystem_name=None, releases=None,
+                        purposes=None):
     """Return arbitrary operating system, and make it "usable."
 
     A usable operating system is one for which boot images are available.
@@ -83,8 +88,11 @@
         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.
+    :param purposse: The list of purposes. Useful in cases where
+        we need to test that not supplying a purpose works correctly.
     """
     osystem = make_osystem_with_releases(
-        testcase, osystem_name=osystem_name, releases=releases)
+        testcase, osystem_name=osystem_name, releases=releases,
+        purposes=purposes)
     patch_usable_osystems(testcase, [osystem])
     return osystem
 
=== modified file 'src/maasserver/tests/test_api_node.py'
--- src/maasserver/tests/test_api_node.py	2014-04-25 18:03:38 +0000
+++ src/maasserver/tests/test_api_node.py	2014-05-29 17:03:44 +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,
     )
@@ -40,6 +39,7 @@
 from maasserver.testing.architecture import make_usable_architecture
 from maasserver.testing.factory import factory
 from maasserver.testing.oauthclient import OAuthAuthenticatedClient
+from maasserver.testing.osystems import make_usable_osystem
 from maasserver.testing.testcase import MAASServerTestCase
 from maasserver.utils import map_enum
 from metadataserver.models import (
@@ -221,24 +221,31 @@
         self.assertEqual(
             node.system_id, json.loads(response.content)['system_id'])
 
-    def test_POST_start_sets_distro_series(self):
+    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')
-        distro_series = factory.getRandomEnum(DISTRO_SERIES)
+            power_type='ether_wake',
+            architecture=make_usable_architecture(self))
+        osystem = make_usable_osystem(self)
+        distro_series = factory.getRandomRelease(osystem)
         response = self.client.post(
-            self.get_node_uri(node),
-            {'op': 'start', 'distro_series': distro_series})
+            self.get_node_uri(node), {
+                'op': 'start',
+                '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_validates_distro_series(self):
         node = factory.make_node(
             owner=self.logged_in_user, mac=True,
-            power_type='ether_wake')
+            power_type='ether_wake',
+            architecture=make_usable_architecture(self))
         invalid_distro_series = factory.getRandomString()
         response = self.client.post(
             self.get_node_uri(node),
@@ -247,7 +254,8 @@
             (
                 httplib.BAD_REQUEST,
                 {'distro_series': [
-                    "Value u'%s' is not a valid choice." %
+                    "'%s' is not a valid distro_series.  "
+                    "It should be one of: ''." %
                     invalid_distro_series]}
             ),
             (response.status_code, json.loads(response.content)))
@@ -300,18 +308,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-05-20 02:58:09 +0000
+++ src/maasserver/tests/test_api_pxeconfig.py	2014-05-29 17:03:44 +0000
@@ -35,11 +35,13 @@
     )
 from maasserver.testing.architecture import make_usable_architecture
 from maasserver.testing.factory import factory
+from maasserver.testing.osystems import make_usable_osystem
 from maasserver.testing.testcase import MAASServerTestCase
 from maastesting.fakemethod import FakeMethod
 from mock import Mock
 from netaddr import IPNetwork
 from provisioningserver import kernel_opts
+from provisioningserver.driver import BOOT_IMAGE_PURPOSE
 from provisioningserver.kernel_opts import KernelParameters
 from testtools.matchers import (
     Contains,
@@ -133,7 +135,7 @@
         self.assertEqual(value, response_dict['extra_opts'])
 
     def test_pxeconfig_uses_present_boot_image(self):
-        osystem = 'ubuntu'
+        osystem = Config.objects.get_config('commissioning_osystem')
         release = Config.objects.get_config('commissioning_distro_series')
         nodegroup = factory.make_node_group()
         factory.make_boot_image(
@@ -284,7 +286,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
@@ -307,11 +310,33 @@
                 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_get_boot_purpose_osystem_no_xinstall_support(self):
+        osystem = make_usable_osystem(
+            self, purposes=[BOOT_IMAGE_PURPOSE.INSTALL])
+        release = factory.getRandomRelease(osystem)
+        node = factory.make_node(
+            status=NODE_STATUS.ALLOCATED, netboot=True,
+            osystem=osystem.name, distro_series=release)
+        node.use_fastpath_installer()
+        node_os = node.get_osystem()
+        node_series = node.get_distro_series()
+        arch, subarch = node.architecture.split('/')
+        self.assertEqual(
+            'install',
+            api.get_boot_purpose(
+                node, node_os, arch, subarch, node_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_forms.py'
--- src/maasserver/tests/test_forms.py	2014-05-20 14:16:58 +0000
+++ src/maasserver/tests/test_forms.py	2014-05-29 17:03:44 +0000
@@ -53,6 +53,8 @@
     InstanceListField,
     INTERFACES_VALIDATION_ERROR_MESSAGE,
     list_all_usable_architectures,
+    list_all_usable_osystems,
+    list_all_usable_releases,
     MACAddressForm,
     MAX_MESSAGES,
     merge_error_messages,
@@ -98,6 +100,11 @@
     patch_usable_architectures,
     )
 from maasserver.testing.factory import factory
+from maasserver.testing.osystems import (
+    make_osystem_with_releases,
+    make_usable_osystem,
+    patch_usable_osystems,
+    )
 from maasserver.testing.testcase import MAASServerTestCase
 from maasserver.utils import map_enum
 from maasserver.utils.forms import compose_invalid_choice_text
@@ -120,8 +127,8 @@
 
 class TestHelpers(MAASServerTestCase):
 
-    def make_usable_boot_images(self, nodegroup=None, arch=None,
-                                subarchitecture=None):
+    def make_usable_boot_images(self, nodegroup=None, osystem=None,
+                                arch=None, subarchitecture=None, release=None):
         """Create a set of boot images, so the architecture becomes "usable".
 
         This will make the images' architecture show up in the list of usable
@@ -131,14 +138,19 @@
         """
         if nodegroup is None:
             nodegroup = factory.make_node_group()
+        if osystem is None:
+            osystem = factory.make_name('os')
         if arch is None:
             arch = factory.make_name('arch')
         if subarchitecture is None:
             subarchitecture = factory.make_name('subarch')
+        if release is None:
+            release = factory.make_name('release')
         for purpose in ['install', 'commissioning']:
             factory.make_boot_image(
-                nodegroup=nodegroup, architecture=arch,
-                subarchitecture=subarchitecture, purpose=purpose)
+                nodegroup=nodegroup, osystem=osystem, architecture=arch,
+                subarchitecture=subarchitecture, release=release,
+                purpose=purpose)
 
     def test_initialize_node_group_leaves_nodegroup_reference_intact(self):
         preselected_nodegroup = factory.make_node_group()
@@ -201,6 +213,67 @@
         arches = [factory.make_name('arch') for _ in range(5)]
         self.assertEqual(arches[0], pick_default_architecture(arches))
 
+    def test_list_all_usable_osystems_combines_nodegroups(self):
+        osystem_names = [factory.make_name('os') for _ in range(3)]
+        expected = []
+        for name in osystem_names:
+            self.make_usable_boot_images(osystem=name)
+            expected.append(make_usable_osystem(self, name))
+        self.assertItemsEqual(expected, list_all_usable_osystems())
+
+    def test_list_all_usable_osystems_sorts_output(self):
+        osystem_names = [factory.make_name('os') for _ in range(3)]
+        expected = []
+        for name in osystem_names:
+            self.make_usable_boot_images(osystem=name)
+            expected.append(make_usable_osystem(self, name))
+        expected = sorted(expected, key=lambda osystem: osystem.title)
+        self.assertEqual(expected, list_all_usable_osystems())
+
+    def test_list_all_usable_osystems_returns_no_duplicates(self):
+        os_name = factory.make_name('os')
+        self.make_usable_boot_images(osystem=os_name)
+        self.make_usable_boot_images(osystem=os_name)
+        osystem = make_usable_osystem(self, os_name)
+        self.assertEqual(
+            [osystem], list_all_usable_osystems())
+
+    def test_list_all_usable_releases_combines_nodegroups(self):
+        expected = {}
+        osystems = []
+        os_names = [factory.make_name('os') for _ in range(3)]
+        for name in os_names:
+            releases = [factory.make_name('release') for _ in range(3)]
+            for release in releases:
+                self.make_usable_boot_images(osystem=name, release=release)
+            osystems.append(
+                make_usable_osystem(self, name, releases=releases))
+            expected[name] = releases
+        self.assertItemsEqual(expected, list_all_usable_releases(osystems))
+
+    def test_list_all_usable_releases_sorts_output(self):
+        expected = {}
+        osystems = []
+        os_names = [factory.make_name('os') for _ in range(3)]
+        for name in os_names:
+            releases = [factory.make_name('release') for _ in range(3)]
+            for release in releases:
+                self.make_usable_boot_images(osystem=name, release=release)
+            osystems.append(
+                make_usable_osystem(self, name, releases=releases))
+            expected[name] = sorted(releases)
+        self.assertEqual(expected, list_all_usable_releases(osystems))
+
+    def test_list_all_usable_releases_returns_no_duplicates(self):
+        os_name = factory.make_name('os')
+        release = factory.make_name('release')
+        self.make_usable_boot_images(osystem=os_name, release=release)
+        self.make_usable_boot_images(osystem=os_name, release=release)
+        osystem = make_usable_osystem(self, os_name, releases=[release])
+        expected = {}
+        expected[os_name] = [release]
+        self.assertEqual(expected, list_all_usable_releases([osystem]))
+
     def test_remove_None_values_removes_None_values_in_dict(self):
         random_input = factory.getRandomString()
         self.assertEqual(
@@ -430,6 +503,7 @@
             [
                 'hostname',
                 'architecture',
+                'osystem',
                 'distro_series',
                 'nodegroup',
             ], list(form.fields))
@@ -489,6 +563,77 @@
             [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)
+
+    def test_rejects_mismatch_osystem_distro_series(self):
+        osystem = make_usable_osystem(self)
+        release = osystem.get_default_release()
+        invalid = factory.make_name('invalid_os')
+        form = NodeForm(data={
+            'hostname': factory.make_name('host'),
+            'architecture': make_usable_architecture(self),
+            'osystem': osystem.name,
+            'distro_series': '%s/%s' % (invalid, release),
+            })
+        self.assertFalse(form.is_valid())
+        self.assertItemsEqual(['distro_series'], form._errors.keys())
+
 
 class TestAdminNodeForm(MAASServerTestCase):
 
@@ -500,6 +645,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-05-13 18:43:40 +0000
+++ src/maasserver/tests/test_preseed.py	2014-05-29 17:03:44 +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,7 +589,7 @@
         node = factory.make_node()
         arch, subarch = node.architecture.split('/')
         factory.make_boot_image(
-            osystem='ubuntu',
+            osystem=node.get_osystem(),
             architecture=arch, subarchitecture=subarch,
             release=node.get_distro_series(), purpose='xinstall',
             nodegroup=node.nodegroup)
@@ -678,18 +677,15 @@
         self.assertIn('cloud-init', context['curtin_preseed'])
 
     def test_get_curtin_installer_url_returns_url(self):
-        osystem = 'ubuntu'
-        # 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,
+            osystem=osystem.name, architecture=architecture,
             distro_series=series)
         arch, subarch = architecture.split('/')
         boot_image = factory.make_boot_image(
-            osystem=osystem, architecture=arch,
+            osystem=osystem.name, architecture=arch,
             subarchitecture=subarch, release=series,
             purpose='xinstall', nodegroup=node.nodegroup)
 
@@ -698,20 +694,20 @@
         [interface] = node.nodegroup.get_managed_interfaces()
         self.assertEqual(
             'http://%s/MAAS/static/images/%s/%s/%s/%s/%s/root-tgz' % (
-                interface.ip, osystem, arch, subarch,
+                interface.ip, osystem.name, arch, subarch,
                 series, boot_image.label),
             installer_url)
 
     def test_get_curtin_installer_url_fails_if_no_boot_image(self):
-        osystem = 'ubuntu'
-        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,
+            osystem=osystem.name,
             architecture=factory.make_name('arch'),
             subarchitecture=factory.make_name('subarch'), release=series,
             purpose='xinstall', nodegroup=node.nodegroup)
@@ -722,7 +718,7 @@
         msg = (
             "No image could be found for the given selection: "
             "os=%s, arch=%s, subarch=%s, series=%s, purpose=xinstall." % (
-                osystem,
+                osystem.name,
                 arch,
                 subarch,
                 node.get_distro_series(),
 
=== 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-05-29 17:03:44 +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_settings.py'
--- src/maasserver/views/tests/test_settings.py	2014-04-10 13:43:33 +0000
+++ src/maasserver/views/tests/test_settings.py	2014-05-29 17:03:44 +0000
@@ -20,14 +20,11 @@
 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 import (
     Config,
     UserProfile,
     )
+from maasserver.models.config import DEFAULT_OS
 from maasserver.testing import (
     extract_redirect,
     get_prefixed_form_data,
@@ -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-04-23 16:09:39 +0000
+++ src/metadataserver/tests/test_api.py	2014-05-29 17:03:44 +0000
@@ -394,7 +394,7 @@
         node = factory.make_node()
         arch, subarch = node.architecture.split('/')
         factory.make_boot_image(
-            osystem='ubuntu',
+            osystem=node.get_osystem(),
             architecture=arch, subarchitecture=subarch,
             release=node.get_distro_series(), purpose='xinstall',
             nodegroup=node.nodegroup)