Merge lp:~ltrager/maas/hwe_backend into lp:~maas-committers/maas/trunk

[Lee Trager]

Enable deploying a specific kernel to a node with validation

If hwe_kernel is specified validate that its newer than min_hwe_kernel and newer than the selected Ubuntu release. If just min_hwe_kernel is specified and the release is older MAAS will automatically select a newer kernel.

[Scott Moser (smoser)]

I think this is intended to fix bug 1473167 ?

If so, when you commit you can:
 bzr commit --fixes lp:1473167

then when you push, launchpad will automagically link the bug to this review.

[Christian Reis (kiko)]

On Wed, Jul 29, 2015 at 12:17:30AM -0000, Lee Trager wrote:
> + print(response.content)

^^^

> + def get_usable_kernels(self, architecture, name):
> + """Return the set of usable kernels for architecture and release."""
> + kernels = set()
> + for resource in self.filter(
> + architecture__startswith=architecture, name=name):
> + resource_set = resource.get_latest_set()
> + if(resource_set is not None and
> + resource_set.commissionable and
> + resource_set.installable):

Would some continues make this ladder less tall?
--
Christian Robottom Reis | [+1] 612 888 4935 | http://launchpad.net/~kiko
Canonical VP Hyperscale | [+55 16] 9 9112 6430

[Lee Trager (ltrager)]

ah sorry wasn't ready to set this for review. I'm still finishing this up. This code will fix 1473167 by checking that the specified kernel is available during deployment. This will also check that the specified kernel is newer than the min_hwe_kernel.

Blake helped me with get_usable_kernels I'll take another look to see if I can break it down some more.

[Blake Rouse (blake-rouse)]

Got lots of comments. This is missing lots of tests and I have some questions and some suggestions that need to be addressed.

review: Needs Fixing

[Mike Pontillo (mpontillo)]

Looks like Blake has got this one well-covered. I'll leave it to him.

review: Abstain

[Lee Trager (ltrager)]

I've made the corrections Blake has asked and added a bunch of tests.

Christian, I looked over get_usable_architectures, is this what your looking for?

arches = set()
for resource in self.all():
    resource_set = resource.get_latest_set()
    if (not resource_set or
       not resource_set.commissionable or
       not resource_set.installable):
        continue
    arches.add(resource.architecture)
    if 'subarches' in resource.extra:
        arch, _ = resource.split_arch()
        for subarch in resource.extra['subarches'].split(','):
            arches.add('%s/%s' % (arch, subarch.strip()))
return arches

review: Needs Resubmitting

[Blake Rouse (blake-rouse)]

This is looking very very close. Only a couple fixes that are still required.

As for the testing of the Form, you are doing it all at the API level. This is okay as I don't want you to have to go and change it all. Normally what we do is test in at the Form level first. Its easier to setup for testing and any exceptions will be raise in the test. By testing at the API level the exceptions will not be raised you have to check the HTTP code to make sure no errors happened. You also need to test at the API level, but just based stuff like: did it use the form, did it raise a validation error, did it return a result. All the other complex combinations of validation should be tested at the form level.

Also the "Resubmit" is to be used by a review to say, please redo the entire branch and resubmit as something is really wrong. Like its targeted to the wrong branch or something. If you need another review from the reviewer just comment on the MP or message them on IRC.

review: Needs Fixing

[Blake Rouse (blake-rouse)]

This looks really good. Not going to block you on the one comment, but I do believe it needs fixing before this branch lands.

Also have you been doing deployments with the branch and the HWE kernel to make sure this is getting you the expected resulted on a deployed node?

review: Approve

[Lee Trager (ltrager)]

I've expanded the get_usable_kernels test, let me know if you think it needs more.

I've been running a full make test as well as deploying the proposed bits into a virtual environment to ensure everything works as it should in the real world. Right now most of my testing has been while using the CLI instead of UI. My next patchset will be focused on the UI

=== modified file 'src/maasserver/api/pxeconfig.py'
--- src/maasserver/api/pxeconfig.py	2015-07-30 18:14:27 +0000
+++ src/maasserver/api/pxeconfig.py	2015-08-05 20:09:04 +0000
@@ -203,6 +203,17 @@
         hostname = strip_domain(node.hostname)
         nodegroup = node.nodegroup
         domain = nodegroup.name
+
+        # Pre MAAS-1.9 the subarchitecture defined any kernel the node needed
+        # to be able to boot. This could be a hardware enablement kernel(e.g
+        # hwe-t) or something like highbank. With MAAS-1.9 any hardware
+        # enablement kernel must be specifed in the hwe_kernel field, any other
+        # kernel, such as highbank, is still specifed as a
+        # subarchitecture. Since Ubuntu does not support architecture specific
+        # hardware enablement kernels(i.e a highbank hwe-t kernel on precise)
+        # we give precedence to any kernel defined in the subarchitecture field
+        if subarch == "generic" and node.hwe_kernel:
+            subarch = node.hwe_kernel
     else:
         nodegroup = find_nodegroup_for_pxeconfig_request(request)
         preseed_url = compose_enlistment_preseed_url(nodegroup=nodegroup)

=== modified file 'src/maasserver/api/tests/test_node.py'
--- src/maasserver/api/tests/test_node.py	2015-07-27 20:23:17 +0000
+++ src/maasserver/api/tests/test_node.py	2015-08-05 20:09:04 +0000
@@ -37,6 +37,7 @@
     MAC_ERROR_MSG,
 )
 from maasserver.models import (
+    BootResource,
     MACAddress,
     Node,
     node as node_module,
@@ -524,7 +525,29 @@
         self.assertEqual(httplib.OK, response.status_code)
         self.assertEqual(user_data, NodeUserData.objects.get_user_data(node))
 
+    def test_POST_start_sets_default_hwe_kernel(self):
+        self.patch(
+            BootResource.objects,
+            'get_usable_kernels').return_value = ('hwe-t', 'hwe-u')
+        osystem = make_usable_osystem(self, 'ubuntu', ['trusty'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(self))
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+            })
+        self.assertEqual(httplib.OK, response.status_code)
+        self.assertEqual(
+            'hwe-' + distro_series[0], reload_object(node).hwe_kernel)
+
     def test_POST_start_sets_hwe_kernel(self):
+        self.patch(
+            BootResource.objects,
+            'get_usable_kernels').return_value = ('hwe-t', 'hwe-v')
         node = factory.make_Node(
             owner=self.logged_in_user, mac=True, power_type='ether_wake',
             architecture=make_usable_architecture(self))
@@ -536,6 +559,148 @@
         self.assertEqual(httplib.OK, response.status_code)
         self.assertEqual('hwe-v', reload_object(node).hwe_kernel)
 
+    def test_POST_start_fails_with_nongeneric_arch_and_hwe_kernel(self):
+        osystem = make_usable_osystem(self, 'ubuntu', ['trusty'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(self))
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'hwe_kernel': 'hwe-v',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code,
+                         response.content)
+        self.assertEqual(
+            {'hwe_kernel':
+             ["Subarchitecture(%s) must be generic when setting hwe_kernel." %
+              node.split_arch()[1]]},
+            json.loads(response.content))
+
+    def test_POST_start_fails_with_missing_hwe_kernel(self):
+        self.patch(
+            BootResource.objects,
+            'get_usable_kernels').return_value = ('hwe-t', 'hwe-u')
+        osystem = make_usable_osystem(self, 'ubuntu', ['trusty'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(
+                self, subarch_name='generic'))
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'hwe_kernel': 'hwe-v',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code,
+                         response.content)
+        self.assertEqual(
+            {'hwe_kernel':
+             ["hwe-v is not avaliable for %s/%s on %s." %
+              (osystem['name'], distro_series, node.architecture)]},
+            json.loads(response.content))
+
+    def test_POST_start_fails_with_old_kernel_and_newer_release(self):
+        self.patch(
+            BootResource.objects,
+            'get_usable_kernels').return_value = ('hwe-t', 'hwe-v')
+        osystem = make_usable_osystem(self, 'ubuntu', ['vivid'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(
+                self, subarch_name='generic'))
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+                'hwe_kernel': 'hwe-t',
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code,
+                         response.content)
+        self.assertEqual(
+            {'hwe_kernel':
+             ["hwe-t is too old to use on ubuntu/vivid."]},
+            json.loads(response.content))
+
+    def test_POST_start_fails_with_old_kernel_and_newer_min_hwe_kernel(self):
+        self.patch(
+            BootResource.objects,
+            'get_usable_kernels').return_value = ('hwe-t', 'hwe-v')
+        osystem = make_usable_osystem(self, 'ubuntu', ['precise'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(
+                self, subarch_name='generic'),
+            min_hwe_kernel='hwe-v')
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+                'hwe_kernel': 'hwe-t',
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code,
+                         response.content)
+        self.assertEqual(
+            {'hwe_kernel':
+             ["hwe_kernel(hwe-t) is older than min_hwe_kernel(hwe-v)."]},
+            json.loads(response.content))
+
+    def test_POST_start_fails_with_no_avalible_kernels(self):
+        self.patch(
+            BootResource.objects,
+            'get_usable_kernels').return_value = ('hwe-t', 'hwe-v')
+        osystem = make_usable_osystem(self, 'ubuntu', ['precise'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(
+                self, subarch_name='generic'),
+            min_hwe_kernel='hwe-v')
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+                'hwe_kernel': 'hwe-t',
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code,
+                         response.content)
+        self.assertEqual(
+            {'hwe_kernel':
+             ["hwe_kernel(hwe-t) is older than min_hwe_kernel(hwe-v)."]},
+            json.loads(response.content))
+
+    def test_POST_start_with_old_release_and_newer_min_hwe_kernel(self):
+        osystem = make_usable_osystem(self, 'ubuntu', ['trusty'])
+        distro_series = osystem['default_release']
+        node = factory.make_Node(
+            owner=self.logged_in_user, mac=True, power_type='ether_wake',
+            architecture=make_usable_architecture(
+                self, subarch_name='generic'),
+            min_hwe_kernel='hwe-v')
+        response = self.client.post(
+            self.get_node_uri(node), {
+                'op': 'start',
+                'distro_series': distro_series,
+                'osystem': osystem['name'],
+            })
+        self.assertEqual(httplib.BAD_REQUEST, response.status_code,
+                         response.content)
+        self.assertEqual(
+            {'hwe_kernel':
+             ["trusty has no kernels availible which meet " +
+              "min_hwe_kernel(hwe-v)."]},
+            json.loads(response.content))
+
     def test_POST_release_releases_owned_node(self):
         self.patch(node_module, 'power_off_node')
         self.patch(node_module.Node, 'start_transition_monitor')

=== modified file 'src/maasserver/forms.py'
--- src/maasserver/forms.py	2015-07-31 23:12:15 +0000
+++ src/maasserver/forms.py	2015-08-05 20:09:04 +0000
@@ -388,6 +388,96 @@
 
 class NodeForm(MAASModelForm):
 
+    def _release_a_newer_than_b(self, a, b):
+        """ Compare two Ubuntu releases and return true if a >= b
+
+        The release names can be the full release name(e.g Precise, Trusty), or
+        a hardware enablement(e.g hwe-p, hwe-t). The function wraps around the
+        letter 'p' as Precise was the first version of Ubuntu MAAS supported
+        """
+        def get_release_num(release):
+            release = release.lower()
+            if 'hwe-' in release:
+                release = release.lstrip('hwe-')
+            return ord(release[0])
+
+        # Compare release versions based off of the first letter of their
+        # release name or the letter in hwe-<letter>. Wrap around the letter
+        # 'p' as that is the first version of Ubuntu MAAS supported.
+        num_a = get_release_num(a)
+        num_b = get_release_num(b)
+        num_wrap = ord('p')
+
+        if((num_a >= num_wrap and num_b >= num_wrap and num_a >= num_b) or
+           (num_a < num_wrap and num_b >= num_wrap and num_a < num_b) or
+           (num_a < num_wrap and num_b < num_wrap and num_a >= num_b)):
+            return True
+        else:
+            return False
+
+    def _clean_hwe_kernel(self):
+        hwe_kernel = self.cleaned_data.get('hwe_kernel')
+        min_hwe_kernel = self.cleaned_data.get('min_hwe_kernel')
+        architecture = self.cleaned_data.get('architecture')
+        osystem = self.cleaned_data.get('osystem')
+        distro_series = self.cleaned_data.get('distro_series')
+
+        # The hwe_kernel feature is only supported on Ubuntu
+        if((osystem and "ubuntu" not in osystem.lower()) or
+           (not architecture or architecture == '') or
+           (not distro_series or distro_series == '')):
+            return hwe_kernel
+
+        arch, subarch = architecture.split('/')
+
+        if (subarch != 'generic' and
+            (hwe_kernel.startswith('hwe-') or
+             min_hwe_kernel.startswith('hwe-'))):
+            set_form_error(
+                self, 'hwe_kernel',
+                'Subarchitecture(%s) must be generic when setting hwe_kernel.'
+                % subarch)
+            return
+
+        os_release = osystem + '/' + distro_series
+        usable_kernels = BootResource.objects.get_usable_kernels(
+            os_release, arch)
+
+        if hwe_kernel.startswith('hwe-'):
+            if hwe_kernel not in usable_kernels:
+                set_form_error(
+                    self, 'hwe_kernel',
+                    '%s is not avaliable for %s on %s.' %
+                    (hwe_kernel, os_release, architecture))
+                return
+            if not self._release_a_newer_than_b(hwe_kernel, distro_series):
+                set_form_error(
+                    self, 'hwe_kernel',
+                    '%s is too old to use on %s.' % (hwe_kernel, os_release))
+                return
+
+        if(hwe_kernel.startswith('hwe-') and
+           min_hwe_kernel.startswith('hwe-') and
+           not self._release_a_newer_than_b(hwe_kernel, min_hwe_kernel)):
+            set_form_error(
+                self, 'hwe_kernel',
+                'hwe_kernel(%s) is older than min_hwe_kernel(%s).' %
+                (hwe_kernel, min_hwe_kernel))
+            return
+        elif(min_hwe_kernel.startswith('hwe-')):
+            for i in usable_kernels:
+                if self._release_a_newer_than_b(i, min_hwe_kernel):
+                    return i
+            set_form_error(
+                self, 'hwe_kernel',
+                '%s has no kernels availible which meet min_hwe_kernel(%s).' %
+                (distro_series, min_hwe_kernel))
+            return
+        elif hwe_kernel.strip() == '':
+            return 'hwe-' + distro_series[0]
+
+        return hwe_kernel
+
     def __init__(self, request=None, *args, **kwargs):
         super(NodeForm, self).__init__(*args, **kwargs)
         # Even though it doesn't need it and doesn't use it, this form accepts
@@ -574,6 +664,7 @@
             # Take the default value from the node's cluster.
             nodegroup = cleaned_data['nodegroup']
             cleaned_data['disable_ipv4'] = nodegroup.default_disable_ipv4
+        cleaned_data['hwe_kernel'] = self._clean_hwe_kernel()
         return cleaned_data
 
     def is_valid(self):

=== modified file 'src/maasserver/models/bootresource.py'
--- src/maasserver/models/bootresource.py	2015-06-02 08:46:21 +0000
+++ src/maasserver/models/bootresource.py	2015-08-05 20:09:04 +0000
@@ -24,6 +24,7 @@
 )
 from maasserver import DefaultMeta
 from maasserver.enum import (
+    BOOT_RESOURCE_FILE_TYPE,
     BOOT_RESOURCE_TYPE,
     BOOT_RESOURCE_TYPE_CHOICES,
     BOOT_RESOURCE_TYPE_CHOICES_DICT,
@@ -223,6 +224,45 @@
             return False
         return True
 
+    def get_usable_kernels(self, name, architecture):
+        """Return the set of usable kernels for architecture and release."""
+        kernels = set()
+        for resource in self.filter(
+                architecture__startswith=architecture, name=name):
+            resource_set = resource.get_latest_set()
+            if(resource_set is None or
+               not resource_set.commissionable or
+               not resource_set.installable):
+                continue
+            subarch = resource.split_arch()[1]
+            if subarch.startswith("hwe-"):
+                kernels.add(subarch)
+            if "subarches" in resource.extra:
+                for subarch in resource.extra["subarches"].split(","):
+                    if subarch.startswith("hwe-"):
+                        kernels.add(subarch)
+        return kernels
+
+    def get_kpackage_for_node(self, node):
+        """Return the kernel package name for the kernel specified."""
+        if not node.hwe_kernel:
+            return None
+        arch = node.split_arch()[0]
+        os_release = node.get_osystem() + '/' + node.get_distro_series()
+        # Before hwe_kernel was introduced the subarchitecture was the
+        # hwe_kernel simple stream still uses this convention
+        hwe_arch = arch + '/' + node.hwe_kernel
+
+        resource = self.filter(name=os_release, architecture=hwe_arch).first()
+        if resource:
+            latest_set = resource.get_latest_set()
+            if latest_set:
+                kernel = latest_set.files.filter(
+                    filetype=BOOT_RESOURCE_FILE_TYPE.BOOT_KERNEL).first()
+                if kernel and 'kpackage' in kernel.extra:
+                    return kernel.extra['kpackage']
+        return None
+
 
 def validate_architecture(value):
     """Validates that architecture value contains a subarchitecture."""

=== modified file 'src/maasserver/models/tests/test_bootresource.py'
--- src/maasserver/models/tests/test_bootresource.py	2015-05-07 18:14:38 +0000
+++ src/maasserver/models/tests/test_bootresource.py	2015-08-05 20:09:04 +0000
@@ -510,6 +510,73 @@
         self.assertTrue(BootResource.objects.boot_images_are_in_sync([image]))
 
 
+class TestGetUsableKernels(MAASServerTestCase):
+    """Tests for `get_usable_kernels`."""
+
+    scenarios = (
+        ("ubuntu/trusty", {
+            "name": "ubuntu/trusty",
+            "arch": "amd64",
+            "subarch": "generic",
+            "kernels": ["hwe-t", "hwe-u", "hwe-v"],
+            }),
+        ("ubuntu/vivid", {
+            "name": "ubuntu/vivid",
+            "arch": "i386",
+            "subarch": "generic",
+            "kernels": ["hwe-v"],
+            }),
+        ("ubuntu/precise", {
+            "name": "ubuntu/precise",
+            "arch": "armfh",
+            "subarch": "generic",
+            "kernels": ["hwe-p", "hwe-t", "hwe-v"],
+            }),
+        ("ubuntu/wily", {
+            "name": "ubuntu/wily",
+            "arch": "armfh",
+            "subarch": "hardbank",
+            "kernels": [],
+        }))
+
+    def test__returns_usable_kernels(self):
+        if self.subarch == "generic":
+            for i in self.kernels:
+                factory.make_usable_boot_resource(
+                    name=self.name, rtype=BOOT_RESOURCE_TYPE.SYNCED,
+                    architecture="%s/%s" % (self.arch, i))
+        else:
+            factory.make_usable_boot_resource(
+                name=self.name, rtype=BOOT_RESOURCE_TYPE.SYNCED,
+                architecture="%s/%s" % (self.arch, self.subarch))
+        self.assertEqual(
+            set(self.kernels),
+            BootResource.objects.get_usable_kernels(
+                self.name, self.arch),
+            "%s should return %s as its usable kernel" % (
+                self.name, set(self.kernels)))
+
+
+class TestGetKpackageForNode(MAASServerTestCase):
+    """Tests for `get_kpackage_for_node`."""
+
+    def test__returns_kpackage(self):
+        resource = factory.make_BootResource(
+            name="ubuntu/trusty", architecture="amd64/hwe-t",
+            rtype=BOOT_RESOURCE_TYPE.SYNCED)
+        resource_set = factory.make_BootResourceSet(resource)
+        factory.make_boot_resource_file_with_content(
+            resource_set, filename="boot-kernel", filetype="boot-kernel",
+            extra={"kpackage": "linux-image-generic-lts-trusty"})
+        node = factory.make_Node(
+            mac=True, power_type='ether_wake', osystem='ubuntu',
+            distro_series='trusty', architecture='amd64/generic',
+            hwe_kernel='hwe-t')
+        self.assertEqual(
+            "linux-image-generic-lts-trusty",
+            BootResource.objects.get_kpackage_for_node(node))
+
+
 class TestBootResource(MAASServerTestCase):
     """Tests for the `BootResource` model."""
 

=== modified file 'src/maasserver/preseed.py'
--- src/maasserver/preseed.py	2015-07-30 20:15:47 +0000
+++ src/maasserver/preseed.py	2015-08-05 20:09:04 +0000
@@ -50,6 +50,7 @@
     PreseedError,
 )
 from maasserver.models import (
+    BootResource,
     Config,
     DHCPLease,
 )
@@ -225,6 +226,24 @@
         return []
 
 
+def compose_curtin_kernel_preseed(node):
+    """Return the curtin preseed for installing a kernel other than default.
+
+    The BootResourceFile table contains a mapping between hwe kernels and
+    Ubuntu package names. If this mapping is missing we fall back to letting
+    Curtin figure out which kernel should be installed"""
+    kpackage = BootResource.objects.get_kpackage_for_node(node)
+    if kpackage:
+        kernel_config = {
+            'kernel': {
+                'package': kpackage,
+                'mapping': {},
+                },
+            }
+        return [yaml.safe_dump(kernel_config)]
+    return []
+
+
 def get_curtin_userdata(node):
     """Return the curtin user-data.
 
@@ -237,6 +256,7 @@
     reporter_config = compose_curtin_maas_reporter(node)
     network_config = compose_curtin_network_preseed_for(node)
     swap_config = compose_curtin_swap_preseed(node)
+    kernel_config = compose_curtin_kernel_preseed(node)
 
     # Get the storage configration if curtin supports custom storage.
     storage_config = compose_curtin_storage_config(node)
@@ -251,7 +271,7 @@
     return pack_install(
         configs=(
             [main_config] + reporter_config + storage_config +
-            network_config + swap_config),
+            network_config + swap_config + kernel_config),
         args=[installer_url])
 
 

=== modified file 'src/maasserver/tests/test_forms_node.py'
--- src/maasserver/tests/test_forms_node.py	2015-07-25 04:02:23 +0000
+++ src/maasserver/tests/test_forms_node.py	2015-08-05 20:09:04 +0000
@@ -578,3 +578,17 @@
         AdminNodeForm(data={'nodegroup': new_nodegroup}, instance=node).save()
         # The form saved without error, but the nodegroup change was ignored.
         self.assertEqual(old_nodegroup, node.nodegroup)
+
+    def test__release_a_newer_than_b(self):
+        form = AdminNodeForm()
+        # Since we wrap around 'p' we want to use 'p' as our starting point
+        alphabet = ([chr(i) for i in xrange(ord('p'), ord('z') + 1)] +
+                    [chr(i) for i in xrange(ord('a'), ord('p'))])
+        previous_true = 0
+        for i in alphabet:
+            true_count = 0
+            for j in alphabet:
+                if form._release_a_newer_than_b(i, j):
+                    true_count += 1
+            previous_true += 1
+            self.assertEqual(previous_true, true_count)

=== modified file 'src/maasserver/tests/test_preseed.py'
--- src/maasserver/tests/test_preseed.py	2015-07-29 14:15:21 +0000
+++ src/maasserver/tests/test_preseed.py	2015-08-05 20:09:04 +0000
@@ -35,8 +35,12 @@
     MissingBootImage,
     PreseedError,
 )
-from maasserver.models import Config
+from maasserver.models import (
+    BootResource,
+    Config,
+)
 from maasserver.preseed import (
+    compose_curtin_kernel_preseed,
     compose_curtin_maas_reporter,
     compose_curtin_network_preseed,
     compose_curtin_swap_preseed,
@@ -837,6 +841,28 @@
         self.assertEqual(swap_preseed, ['swap: {size: 10000000000B}\n'])
 
 
+class TestComposeCurtinKernel(MAASServerTestCase):
+
+    def test__returns_null_kernel(self):
+        node = factory.make_Node()
+        self.assertEqual(node.hwe_kernel, None)
+        kernel_preseed = compose_curtin_kernel_preseed(node)
+        self.assertEqual(kernel_preseed, [])
+
+    def test__returns_set_kernel(self):
+        self.patch(
+            BootResource.objects, 'get_kpackage_for_node').return_value = (
+            'linux-image-generic-lts-vivid')
+        node = factory.make_Node(hwe_kernel='hwe-v')
+        self.assertEqual(node.hwe_kernel, 'hwe-v')
+        kernel_preseed = compose_curtin_kernel_preseed(node)
+        self.assertEqual(kernel_preseed,
+                         ['kernel:\n' +
+                          '  mapping: {}\n' +
+                          '  package: linux-image-generic-lts-vivid\n'
+                          ])
+
+
 class TestComposeCurtinNetworkPreseed(MAASServerTestCase):
 
     def test__returns_list_of_yaml_strings(self):