Merge lp:~blake-rouse/maas/add-osystem-to-bootimage into lp:~maas-committers/maas/trunk

[Blake Rouse]

Adds an operating system field 'osystem' to the BootImage model and restructures the boot-resources folder to add another level for osystem.

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

Adds an operating system field 'osystem' to the BootImage model. Selection of a BootImage is now based on the operating system to be booted. Currently this is hard coded to 'ubuntu', following changes remove this hard code. The WebUI is updated to show the 'osystem' field in the BootImage list.

The folder structure of the boot-resources folder has also added another level. Currently it is structured arch/subarch/release/label, the new structure puts those folders inside a folder with the operating system name. So the new structure is osystem/arch/subarch/release/label (e.g. ubuntu/amd64/generic/trusty/release).

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

Changes were coordinated with allenap.

[Julian Edwards (julian-edwards)]

-----BEGIN PGP SIGNED MESSAGE-----
Hash: SHA1

 review: approve

Wow, adding something as simple as an OS name was quite a lot of
changes! Thanks for doing this, it's a very nice branch.

I have a couple of niggles but it looks mostly OK to me. Please land
it once these are addressed.

[1]

> + 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)

Can you add tests for these new functions please. Also they are not
actually used anywhere, I presume a follow up branch makes use of them?

[2]

Please run "make lint" and fix all the errors it finds.

-----BEGIN PGP SIGNATURE-----
Version: GnuPG v1
Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/

iEYEARECAAYFAlNYfxYACgkQWhGlTF8G/HefwwCfWwiomUOBgXKO3Z4mf/YGEfpL
VaEAniGAr/MpfihFXHwJBKOekqD2KGOp
=VxoG
-----END PGP SIGNATURE-----

review: Approve

[Andres Rodriguez (andreserl)]

BTW... How will this affect upgrades? My concern is that if we backport
this after upgrades things will be broken because the location of the
bootimages has now changed right? What should we do about it? Julian, Gavin
any thoughts?
On Apr 23, 2014 11:06 PM, "Julian Edwards" <email address hidden>
wrote:

> Review: Approve
>
> -----BEGIN PGP SIGNED MESSAGE-----
> Hash: SHA1
>
> review: approve
>
> Wow, adding something as simple as an OS name was quite a lot of
> changes! Thanks for doing this, it's a very nice branch.
>
> I have a couple of niggles but it looks mostly OK to me. Please land
> it once these are addressed.
>
> [1]
>
> > + 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)
>
> Can you add tests for these new functions please. Also they are not
> actually used anywhere, I presume a follow up branch makes use of them?
>
> [2]
>
> Please run "make lint" and fix all the errors it finds.
>
>
> -----BEGIN PGP SIGNATURE-----
> Version: GnuPG v1
> Comment: Using GnuPG with Thunderbird - http://www.enigmail.net/
>
> iEYEARECAAYFAlNYfxYACgkQWhGlTF8G/HefwwCfWwiomUOBgXKO3Z4mf/YGEfpL
> VaEAniGAr/MpfihFXHwJBKOekqD2KGOp
> =VxoG
> -----END PGP SIGNATURE-----
>
> --
>
> https://code.launchpad.net/~blake-rouse/maas/add-osystem-to-bootimage/+merge/216923
> You are subscribed to branch lp:maas.
>

[Blake Rouse (blake-rouse)]

I added test for get_usable_osystems and get_useable_releases, these methods get used in the following branches.

Andres you are correct in an issue on upgrade, this should be the only upgrade issue I can think of out of all of these branches. I don't think it would be to hard to handle, as we know the only operating system that is in boot-resources folder is Ubuntu.

So on upgrade move all folders in the boot-resources folder into a sub-folder named ubuntu, except for the grub folder it should not move. The migration already sets all BootImage items to ubuntu, so nothing more need to be done there. Only thing left to do is update the maas.tgt, with ubuntu in the path.

[Andres Rodriguez (andreserl)]

So what can we do to address this? This might also break fast path installer when it goes to download the root tarball because it looks for the tarball in a location that does not expect to have the osrelease. Gavin, Julian, do you think we can just avoid using osrelease in the boot-resources path? Or what can we do to move this forward and not break things?

[Blake Rouse (blake-rouse)]

It should not break fast path installer as all of those paths now include the operating system first. So upon installation the preseed that is sent will have the correct path including the operating system.

If you remove the os from the path, you make it really hard for the boot resources to be identified for other operating systems. As that first path should be the operating system.

[Gavin Panella (allenap)]

What's going to move those boot resources? Can it be done just-in-time? Or do we need to arrange for a run of an import?

My feeling is that we should empty the BootImages table in the migration (both ways) and schedule imports to run.

[Julian Edwards (julian-edwards)]

On 25/04/14 20:24, Gavin Panella wrote:
> What's going to move those boot resources? Can it be done just-in-time? Or do we need to arrange for a run of an import?
>
> My feeling is that we should empty the BootImages table in the migration (both ways) and schedule imports to run.
>

We have the per-cluster built-in migration now, which is called on every
start-up. It can easily shuffle files around as needed, and issue API
calls to update the cluster's BootImages.

[Gavin Panella (allenap)]

> We have the per-cluster built-in migration now, which is called on every
> start-up. It can easily shuffle files around as needed, and issue API
> calls to update the cluster's BootImages.

I had forgotten about that. Indeed, that's the better solution.

[Julian Edwards (julian-edwards)]

On 28/04/14 16:40, Gavin Panella wrote:
>> We have the per-cluster built-in migration now, which is called on every
>> start-up. It can easily shuffle files around as needed, and issue API
>> calls to update the cluster's BootImages.
>
> I had forgotten about that. Indeed, that's the better solution.
>

I should mention that we need to make doubly sure that this stuff gets
called from the right charm hooks!

=== modified file 'src/maasserver/api.py'
--- src/maasserver/api.py	2014-04-28 07:41:51 +0000
+++ src/maasserver/api.py	2014-05-02 19:22:04 +0000
@@ -2440,7 +2440,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, 'ubuntu', series, purpose=purpose)
                 if image is None:
                     arch = 'i386'
                 else:
@@ -2453,7 +2453,7 @@
     # (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, 'ubuntu', 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
@@ -2494,8 +2494,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='ubuntu', 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 +2536,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 +2555,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 +2602,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 +2623,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 +2698,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)
 
=== added file 'src/maasserver/migrations/0076_add_osystem_to_bootimage.py'
--- src/maasserver/migrations/0076_add_osystem_to_bootimage.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/migrations/0076_add_osystem_to_bootimage.py	2014-05-02 19:22:04 +0000
@@ -0,0 +1,275 @@
+# -*- 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.bootsource': {
+            'Meta': {'object_name': 'BootSource'},
+            'cluster': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.NodeGroup']", 'null': 'True'}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'keyring_data': ('django.db.models.fields.BinaryField', [], {'blank': 'True'}),
+            'keyring_filename': ('django.db.models.fields.FilePathField', [], {'max_length': '100', 'blank': 'True'}),
+            'updated': ('django.db.models.fields.DateTimeField', [], {}),
+            'url': ('django.db.models.fields.URLField', [], {'max_length': '200'})
+        },
+        u'maasserver.bootsourceselection': {
+            'Meta': {'object_name': 'BootSourceSelection'},
+            'arches': ('djorm_pgarray.fields.ArrayField', [], {'default': 'None', 'dbtype': "u'text'", 'null': 'True', 'blank': 'True'}),
+            'boot_source': ('django.db.models.fields.related.ForeignKey', [], {'to': u"orm['maasserver.BootSource']"}),
+            'created': ('django.db.models.fields.DateTimeField', [], {}),
+            u'id': ('django.db.models.fields.AutoField', [], {'primary_key': 'True'}),
+            'labels': ('djorm_pgarray.fields.ArrayField', [], {'default': 'None', 'dbtype': "u'text'", 'null': 'True', 'blank': 'True'}),
+            'release': ('django.db.models.fields.CharField', [], {'default': "u''", 'max_length': '20', 'null': 'True', 'blank': 'True'}),
+            'subarches': ('djorm_pgarray.fields.ArrayField', [], {'default': 'None', 'dbtype': "u'text'", 'null': 'True', 'blank': 'True'}),
+            '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
 
=== 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-05-02 19:22:04 +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/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-05-02 19:22:04 +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/preseed.py'
--- src/maasserver/preseed.py	2014-04-10 13:43:33 +0000
+++ src/maasserver/preseed.py	2014-05-02 19:22:04 +0000
@@ -93,6 +93,7 @@
 
 def get_curtin_installer_url(node):
     """Return the URL where curtin on the node can download its installer."""
+    osystem = 'ubuntu'
     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/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-05-02 19:22:04 +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 }}</td>
             <td>{{ bootimage.release }}</td>
             <td>{{ bootimage.architecture }}</td>
             <td>{{ bootimage.subarchitecture }}</td>
 
=== 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-05-02 19:22:04 +0000
@@ -427,9 +427,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 +446,7 @@
             label = self.make_name('label')
         return BootImage.objects.create(
             nodegroup=nodegroup,
+            osystem=osystem,
             architecture=architecture,
             subarchitecture=subarchitecture,
             release=release,
 
=== 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-05-02 19:22:04 +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_pxeconfig.py'
--- src/maasserver/tests/test_api_pxeconfig.py	2014-03-27 04:15:45 +0000
+++ src/maasserver/tests/test_api_pxeconfig.py	2014-05-02 19:22:04 +0000
@@ -133,9 +133,11 @@
         self.assertEqual(value, response_dict['extra_opts'])
 
     def test_pxeconfig_uses_present_boot_image(self):
+        osystem = 'ubuntu'
         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()
 
=== 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-05-02 19:22:04 +0000
@@ -590,6 +590,7 @@
         node = factory.make_node()
         arch, subarch = node.architecture.split('/')
         factory.make_boot_image(
+            osystem='ubuntu',
             architecture=arch, subarchitecture=subarch,
             release=node.get_distro_series(), purpose='xinstall',
             nodegroup=node.nodegroup)
@@ -677,27 +678,32 @@
         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)
         architecture = make_usable_architecture(self)
         node = factory.make_node(
-            architecture=architecture, distro_series=series)
+            architecture=architecture,
+            distro_series=series)
         arch, subarch = architecture.split('/')
         boot_image = factory.make_boot_image(
-            architecture=arch, subarchitecture=subarch, release=series,
+            osystem=osystem, 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, 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)
         architecture = make_usable_architecture(self)
@@ -705,6 +711,7 @@
             architecture=architecture, distro_series=series)
         # Generate a boot image with a different arch/subarch.
         factory.make_boot_image(
+            osystem=osystem,
             architecture=factory.make_name('arch'),
             subarchitecture=factory.make_name('subarch'), release=series,
             purpose='xinstall', nodegroup=node.nodegroup)
@@ -714,7 +721,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,
                 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-05-02 19:22:04 +0000
@@ -280,5 +280,5 @@
         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/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-05-02 19:22:04 +0000
@@ -54,8 +54,7 @@
         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)]
+        [factory.make_boot_image(nodegroup=nodegroup) for _ in range(4)]
         response = self.client.get(
             reverse('cluster-bootimages-list', args=[nodegroup.uuid]))
         self.assertEqual(httplib.OK, response.status_code)
 
=== 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-05-02 19:22:04 +0000
@@ -394,6 +394,7 @@
         node = factory.make_node()
         arch, subarch = node.architecture.split('/')
         factory.make_boot_image(
+            osystem='ubuntu',
             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-05-02 19:22:04 +0000
@@ -168,7 +168,7 @@
         """
         def image_dir(params):
             return compose_image_path(
-                params.arch, params.subarch,
+                'ubuntu', 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-05-02 19:22:04 +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='ubuntu', arch=params.arch, subarch=params.subarch,
             release=params.release, label=params.label)
         self.assertThat(
             output, MatchesAll(
@@ -268,7 +268,8 @@
             section = config[section_label]
             self.assertThat(
                 section, ContainsAll(("KERNEL", "INITRD", "APPEND")))
-            contains_arch_path = StartsWith("%s/" % section_label)
+            contains_arch_path = StartsWith(
+                "ubuntu/%s/" % 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-05-02 19:22:04 +0000
@@ -62,6 +62,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 +73,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):
 
=== 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-05-02 19:22:04 +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='ubuntu', 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-05-02 19:22:04 +0000
@@ -29,12 +29,13 @@
 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 +44,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):
@@ -116,7 +117,7 @@
     The path must consist of a full [architecture, subarchitecture, release]
     that identify a kind of boot that we may need an image for.
     """
-    arch, subarch, release, label = path
+    osystem, arch, subarch, release, label = path
     # XXX: rvb 2014-03-24: The images import script currently imports all the
     # images for the configured selections (where a selection is an
     # arch/subarch/series/label combination).  When the import script grows the
@@ -125,7 +126,7 @@
     purposes = ['commissioning', 'install', 'xinstall']
     return [
         dict(
-            architecture=arch, subarchitecture=subarch,
+            osystem=osystem, architecture=arch, subarchitecture=subarch,
             release=release, label=label, purpose=purpose)
         for purpose in purposes
         ]
@@ -139,9 +140,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 +154,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-25 10:42:10 +0000
+++ src/provisioningserver/import_images/boot_resources.py	2014-05-02 19:22:04 +0000
@@ -45,7 +45,7 @@
     """Raised when the config file for the script doesn't exist."""
 
 
-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
@@ -59,6 +59,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
@@ -67,7 +68,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
@@ -110,17 +117,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')
 
=== modified file 'src/provisioningserver/import_images/download_resources.py'
--- src/provisioningserver/import_images/download_resources.py	2014-04-28 09:16:32 +0000
+++ src/provisioningserver/import_images/download_resources.py	2014-05-02 19:22:04 +0000
@@ -251,6 +251,7 @@
     """
     storage_path = os.path.abspath(storage_path)
     snapshot_path = compose_snapshot_path(storage_path)
+    ubuntu_path = os.path.join(snapshot_path, 'ubuntu')
     # Use a FileStore as our ObjectStore implementation.  It will write to the
     # cache directory.
     cache_path = os.path.join(storage_path, 'cache')
@@ -260,7 +261,7 @@
 
     for source in sources:
         download_boot_resources(
-            source['path'], store, snapshot_path, product_mapping,
+            source['path'], store, ubuntu_path, product_mapping,
             keyring=source['keyring'])
 
     return snapshot_path
 
=== modified file 'src/provisioningserver/import_images/tests/test_boot_resources.py'
--- src/provisioningserver/import_images/tests/test_boot_resources.py	2014-04-25 10:42:10 +0000
+++ src/provisioningserver/import_images/tests/test_boot_resources.py	2014-05-02 19:22:04 +0000
@@ -51,9 +51,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)
@@ -63,8 +64,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.
@@ -276,7 +278,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-05-02 19:22:04 +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,
 
=== 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-05-02 19:22:04 +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-05-02 19:22:04 +0000
@@ -171,6 +171,7 @@
         # serialised correctly.
 
         # Example boot image definitions.
+        osystems = "ubuntu", "centos"
         archs = "i386", "amd64"
         subarchs = "generic", "special"
         releases = "precise", "trusty"
@@ -179,7 +180,7 @@
 
         # 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))
 
         # Ensure that list_boot_images() uses the above TFTP file tree.
@@ -187,14 +188,15 @@
 
         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-05-02 19:22:04 +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-05-02 19:22:04 +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([