Merge lp:~justinkov/maas/ephemeral into lp:~maas-committers/maas/trunk

[Justin Kovaric]

Add ability for an OS to be deployed ephemerally.

Ephemeral OS support.

[Mike Pontillo (mpontillo)]

Thanks for submitting this merge proposal.

I may not be the correct person to review this change, because I'm not sure I understand the goals for this code.

Overall, this branch looks okay, but there are some things that need fixing. I've made some comments inline below.

The MAAS team aims for 100% code coverage with unit tests, so you'll also need to add those before we can accept this branch.

Thanks for your time and effort on this. Let us know if you have questions.

review: Needs Fixing

[Justin Kovaric (justinkov)]

Added some responses below.

[Blake Rouse (blake-rouse)]

Overall the implementation looks great and the code is clean. It still is missing the level of tests that we require before merging a branch.

review: Needs Fixing

[Andres Rodriguez (andreserl)]

Justin, any updates?

[MAAS Lander (maas-lander)]

Transitioned to Git.

lp:maas has now moved from Bzr to Git.
Please propose your branches with Launchpad using Git.

git clone https://git.launchpad.net/maas

Unmerged revisions

5656. By Justin Kovaric <email address hidden> <email address hidden> on 2017-06-23

added comment

5655. By Justin Kovaric <email address hidden> <email address hidden> on 2017-06-23

more unit tests.

5654. By Justin Kovaric <email address hidden> <email address hidden> on 2017-06-23

more unit tests

5653. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-31

Added unit test to test ip range addition through api with form encoded data since Django has different ways of handling input.

5652. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-30

Unit test for new kparams attribute of boot resource file.

5651. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-30

changes from make lint run

5650. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-27

results of make format and make lint.

5649. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-27

Added comment.

5648. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-27

Fix so that ephemeral image doesn't boot from local on restart.

5647. By Justin Kovaric <email address hidden> <email address hidden> on 2017-01-26

removed check for root-dd (not needed)

=== modified file 'src/maasserver/api/tests/test_ipranges.py'
--- src/maasserver/api/tests/test_ipranges.py	2016-05-24 22:05:45 +0000
+++ src/maasserver/api/tests/test_ipranges.py	2017-01-31 22:50:18 +0000
@@ -8,6 +8,7 @@
 import http.client
 import json
 import random
+from urllib import parse
 
 from django.conf import settings
 from django.core.urlresolvers import reverse
@@ -76,6 +77,33 @@
         self.assertThat(data['end_ip'], Equals('10.0.0.20'))
         self.assertThat(data['subnet']['id'], Equals(subnet.id))
 
+    def test_create_dynamic_encoded(self):
+        """
+        There is a quirk in Django where the resulting handler will get a
+        mutable dictionary in some instances (with just a json body) and an
+        immutable dictionary in others (In the case for form encoded body).
+
+        Specifying a content type of x-www-form-urlencoded should cause
+        Django to produce an immutable dictionary.
+
+        :return:
+        """
+        self.become_admin()
+        uri = get_ipranges_uri()
+        subnet = factory.make_Subnet(cidr='10.0.0.0/24')
+        response = self.client.post(uri, parse.urlencode(
+            {"type": "dynamic",
+             "start_ip": "10.0.0.10",
+             "end_ip": "10.0.0.20",
+             "subnet": "%d" % subnet.id}),
+            'application/x-www-form-urlencoded')
+        self.assertEqual(
+            http.client.OK, response.status_code, response.content)
+        data = json.loads(response.content.decode(settings.DEFAULT_CHARSET))
+        self.assertThat(data['start_ip'], Equals('10.0.0.10'))
+        self.assertThat(data['end_ip'], Equals('10.0.0.20'))
+        self.assertThat(data['subnet']['id'], Equals(subnet.id))
+
     def test_create_dynamic_requires_admin(self):
         uri = get_ipranges_uri()
         subnet = factory.make_Subnet(cidr='10.0.0.0/24')
@@ -172,9 +200,7 @@
             subnet, '10.0.0.2', '10.0.0.10', user=self.user)
         uri = get_iprange_uri(iprange)
         comment = factory.make_name("comment")
-        response = self.client.put(uri, {
-            "comment": comment,
-        })
+        response = self.client.put(uri, {"comment": comment})
         self.assertEqual(
             http.client.OK, response.status_code, response.content)
         self.assertEqual(

=== modified file 'src/maasserver/bootresources.py'
--- src/maasserver/bootresources.py	2016-12-07 12:46:14 +0000
+++ src/maasserver/bootresources.py	2017-01-31 22:50:18 +0000
@@ -592,8 +592,14 @@
         # values to expose in the simplestreams endpoint on the region.
         # src_{package,release,version} is useful in determining where the
         # bootloader came from.
+        #
+        # Updated the list below to allow for a simplestream server to also
+        # provide an extra field called 'kparams' which allows someone to also
+        # specify kernel parameters that are unique to the release. This is
+        # needed for certain ephemeral images.
         for extra_key in [
-                'kpackage', 'src_package', 'src_release', 'src_version']:
+                'kpackage', 'src_package', 'src_release', 'src_version',
+                'kparams']:
             if extra_key in product:
                 rfile.extra[extra_key] = product[extra_key]
 

=== modified file 'src/maasserver/forms_iprange.py'
--- src/maasserver/forms_iprange.py	2016-10-17 06:42:10 +0000
+++ src/maasserver/forms_iprange.py	2017-01-31 22:50:18 +0000
@@ -7,6 +7,8 @@
     "IPRangeForm",
 ]
 
+import copy
+
 from maasserver.forms import MAASModelForm
 from maasserver.models import Subnet
 from maasserver.models.iprange import IPRange
@@ -30,6 +32,8 @@
             self, data=None, instance=None, request=None, *args, **kwargs):
         if data is None:
             data = {}
+        else:
+            data = copy.deepcopy(data)
         # If this is a new IPRange, fill in the 'user' and 'subnet' fields
         # automatically, if necessary.
         if instance is None:

=== modified file 'src/maasserver/models/bootresource.py'
--- src/maasserver/models/bootresource.py	2017-01-09 22:30:23 +0000
+++ src/maasserver/models/bootresource.py	2017-01-31 22:50:18 +0000
@@ -335,6 +335,28 @@
                     return kernel.extra['kpackage']
         return None
 
+    def get_kparams_for_node(self, node):
+        """Return the kernel package name for the kernel specified."""
+        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
+        if node.hwe_kernel is None or node.hwe_kernel == '':
+            hwe_arch = arch + '/generic'
+        else:
+            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 'kparams' in kernel.extra:
+                    return kernel.extra['kparams']
+        return None
+
     def get_available_commissioning_resources(self):
         """Return list of Ubuntu boot resources that can be used for
         commissioning.

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2017-01-27 09:42:18 +0000
+++ src/maasserver/models/node.py	2017-01-31 22:50:18 +0000
@@ -157,6 +157,7 @@
 )
 import petname
 from piston3.models import Token
+from provisioningserver.drivers.osystem import OperatingSystemRegistry
 from provisioningserver.drivers.power.registry import PowerDriverRegistry
 from provisioningserver.events import (
     EVENT_DETAILS,
@@ -2981,7 +2982,18 @@
             # Install the node if netboot is enabled,
             # otherwise boot locally.
             if self.netboot:
-                return "xinstall"
+                arch, subarch = self.split_arch()
+                osystem_obj = OperatingSystemRegistry.get_item(self.osystem,
+                                                               default=None)
+                if osystem_obj is None:
+                    return "xinstall"
+
+                purposes = osystem_obj.get_boot_image_purposes(arch, subarch,
+                                                               '', '*')
+                if "ephemeral" in purposes:
+                    return "ephemeral"
+                else:
+                    return "xinstall"
             else:
                 return "local"
         elif (self.status == NODE_STATUS.DEPLOYED or

=== modified file 'src/maasserver/rpc/boot.py'
--- src/maasserver/rpc/boot.py	2016-11-07 18:07:57 +0000
+++ src/maasserver/rpc/boot.py	2017-01-31 22:50:18 +0000
@@ -7,6 +7,9 @@
     "get_config",
 ]
 
+import re
+import shlex
+
 from django.core.exceptions import (
     ObjectDoesNotExist,
     ValidationError,
@@ -64,6 +67,7 @@
         'commissioning': "commissioning",
         'rescue': "rescue mode",
         'xinstall': "installation",
+        'ephemeral': "ephemeral",
         'local': "local boot",
         'poweroff': "power off",
     }
@@ -114,6 +118,52 @@
     return kernel, initrd, boot_dtb
 
 
+def merge_kparams_with_extra(kparams, extra_kernel_opts):
+    if kparams is None or kparams == '':
+        return extra_kernel_opts
+
+    """
+    This section will merge the kparams with the extra opts. Our goal is to
+    start with what is in kparams and then look to extra_opts for anything
+    to add to or override settings in kparams. Anything in extra_opts, which
+    can be set through tabs, takes precedence so we use that to start with.
+    """
+    final_params = ''
+    if extra_kernel_opts is not None and extra_kernel_opts != '':
+        # We need to remove spaces from the tempita subsitutions so the split
+        #  command works as desired.
+        final_params = re.sub('{{\s*([\w\.]*)\s*}}', '{{\g<1>}}',
+                              extra_kernel_opts)
+
+    # Need to get a list of all kernel params in the extra opts.
+    elist = []
+    if len(final_params) > 0:
+        tmp = shlex.split(final_params)
+        for tparam in tmp:
+            idx = tparam.find('=')
+            key = tparam[0:idx]
+            elist.append(key)
+
+    # Go through all the kernel params as normally set.
+    new_kparams = re.sub('{{\s*([\w\.]*)\s*}}', '{{\g<1>}}', kparams)
+    params = shlex.split(new_kparams)
+    for param in params:
+        idx = param.find('=')
+        key = param[0:idx]
+        value = param[idx + 1:len(param)]
+
+        # The call to split will remove quotes, so we add them back in if
+        #  needed.
+        if value.find(" ") > 0:
+            value = '"' + value + '"'
+
+        # if the param is not in extra_opts, use the one from here.
+        if key not in elist:
+            final_params = final_params + ' ' + key + '=' + value
+
+    return final_params
+
+
 @synchronous
 @transactional
 def get_config(
@@ -233,6 +283,10 @@
                 extra_kernel_opts = None
         else:
             extra_kernel_opts = effective_kernel_opts
+
+        kparams = BootResource.objects.get_kparams_for_node(machine)
+        extra_kernel_opts = merge_kparams_with_extra(kparams,
+                                                     extra_kernel_opts)
     else:
         purpose = "commissioning"  # enlistment
         preseed_url = compose_enlistment_preseed_url(rack_controller)

=== modified file 'src/maasserver/rpc/tests/test_boot.py'
--- src/maasserver/rpc/tests/test_boot.py	2016-11-07 18:07:57 +0000
+++ src/maasserver/rpc/tests/test_boot.py	2017-01-31 22:50:18 +0000
@@ -35,6 +35,7 @@
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
 from maasserver.utils.orm import reload_object
+from maasserver.utils.osystems import get_release_from_distro_info
 from maastesting.matchers import (
     MockCalledOnceWith,
     MockNotCalled,
@@ -59,6 +60,23 @@
             architecture="%s/generic" % architecture.split('/')[0],
             **kwargs)
 
+    def make_node_with_extra(self, arch_name=None, extra=None, **kwargs):
+        """
+        Need since if we pass "extra" as part of kwargs, the code that creates
+        a node will fail since "extra" isn't a valid parameter for that code
+        path.
+
+        :param arch_name:
+        :param extra:
+        :param kwargs:
+        :return:
+        """
+        architecture = make_usable_architecture(self, arch_name=arch_name,
+                                                extra=extra)
+        return factory.make_Node_with_Interface_on_Subnet(
+            architecture="%s/generic" % architecture.split('/')[0],
+            **kwargs)
+
     def test__returns_all_kernel_parameters(self):
         rack_controller = factory.make_RackController()
         local_ip = factory.make_ip_address()
@@ -92,6 +110,44 @@
         # Should not raise BootConfigNoResponse.
         get_config(rack_controller.system_id, local_ip, remote_ip, mac=mac)
 
+    def test__returns_kparams_for_known_node(self):
+        rack_controller = factory.make_RackController()
+        local_ip = factory.make_ip_address()
+        remote_ip = factory.make_ip_address()
+
+        """
+        The make_node function will result in a boot resource being created
+        with an architecture that looks like "arch-YYY/hwe-Z", with YYY being
+        a random string and Z being the first letter of the default
+        commissioning image. If we don't create a node with this same kernel
+        name, the node will use an architecture name of arch-YYY/generic which
+        means the get_config won't find the matching boot resource file with
+        the kparams attribute.
+        """
+        default_series = Config.objects.get_config(
+            name='commissioning_distro_series')
+        release = get_release_from_distro_info(default_series)
+        hwe_kernel = "hwe-%s" % (release['version'].split()[0])
+
+        node = self.make_node_with_extra(status=NODE_STATUS.DEPLOYING,
+                                         extra={'kparams': 'a=b'},
+                                         hwe_kernel=hwe_kernel)
+
+        """
+        Create a tag so that we can make sure the kparams attribute got merged
+        with the tag's kernel_opts attribute.
+        """
+        tag = factory.make_Tag(kernel_opts="b=c")
+        node.tags.add(tag)
+
+        mac = node.get_boot_interface().mac_address
+        config = get_config(rack_controller.system_id, local_ip, remote_ip,
+                            mac=mac)
+        extra = config.get('extra_opts', None)
+
+        self.assertIn('b=c', extra)
+        self.assertIn('a=b', extra)
+
     def test__raises_BootConfigNoResponse_for_unknown_node(self):
         rack_controller = factory.make_RackController()
         local_ip = factory.make_ip_address()

=== modified file 'src/maasserver/testing/architecture.py'
--- src/maasserver/testing/architecture.py	2016-08-30 18:45:05 +0000
+++ src/maasserver/testing/architecture.py	2017-01-31 22:50:18 +0000
@@ -14,7 +14,8 @@
 from maasserver.testing.factory import factory
 
 
-def make_arch(with_subarch=True, arch_name=None, subarch_name=None):
+def make_arch(with_subarch=True, arch_name=None, subarch_name=None,
+              extra=None):
     """Generate an arbitrary architecture name.
 
     :param with_subarch: Should the architecture include a slash and a
@@ -22,7 +23,7 @@
     """
     if arch_name is None:
         arch_name = factory.make_name('arch')
-    factory.make_default_ubuntu_release_bootable(arch_name)
+    factory.make_default_ubuntu_release_bootable(arch_name, extra=extra)
     if with_subarch:
         if subarch_name is None:
             subarch_name = factory.make_name('sub')
@@ -50,7 +51,8 @@
 
 
 def make_usable_architecture(
-        testcase, with_subarch=True, arch_name=None, subarch_name=None):
+        testcase, with_subarch=True, arch_name=None, subarch_name=None,
+        extra=None):
     """Return arbitrary architecture name, and make it "usable."
 
     A usable architecture is one for which boot images are available.
@@ -66,6 +68,6 @@
     """
     arch = make_arch(
         with_subarch=with_subarch, arch_name=arch_name,
-        subarch_name=subarch_name)
+        subarch_name=subarch_name, extra=extra)
     patch_usable_architectures(testcase, [arch])
     return arch

=== modified file 'src/maasserver/testing/factory.py'
--- src/maasserver/testing/factory.py	2017-01-26 18:51:52 +0000
+++ src/maasserver/testing/factory.py	2017-01-31 22:50:18 +0000
@@ -1660,7 +1660,8 @@
             # cases this will always be true. The simplestreams content from
             # maas.io, is formatted this way.
             self.make_boot_resource_file_with_content(
-                resource_set, filename=filename, filetype=filetype, size=None)
+                resource_set, filename=filename, filetype=filetype, size=None,
+                extra=extra)
         return resource
 
     def make_incomplete_boot_resource(
@@ -1690,7 +1691,7 @@
                 size=size, content=content)
         return resource
 
-    def make_default_ubuntu_release_bootable(self, arch=None):
+    def make_default_ubuntu_release_bootable(self, arch=None, extra=None):
         if arch is None:
             arch = self.make_name('arch')
         default_osystem = Config.objects.get_config(
@@ -1708,7 +1709,8 @@
             with transaction.atomic():
                 return self.make_usable_boot_resource(
                     name=default_name, architecture=architecture,
-                    kflavor='generic', rtype=BOOT_RESOURCE_TYPE.SYNCED)
+                    kflavor='generic', rtype=BOOT_RESOURCE_TYPE.SYNCED,
+                    extra=extra)
 
     def make_BlockDevice(
             self, node=None, name=None, id_path=None, size=None,

=== modified file 'src/maasserver/utils/osystems.py'
--- src/maasserver/utils/osystems.py	2017-01-10 09:53:51 +0000
+++ src/maasserver/utils/osystems.py	2017-01-31 22:50:18 +0000
@@ -30,6 +30,7 @@
     BootSourceCache,
     Config,
 )
+from provisioningserver.drivers.osystem import OperatingSystemRegistry
 
 
 def list_all_usable_osystems():
@@ -409,6 +410,16 @@
        (not distro_series or distro_series == '')):
         return hwe_kernel
 
+    # If we are dealing with an ephemeral image, just return the hwe_kernel
+    # as-is, i.e. just stick with generic.
+    osystem_obj = OperatingSystemRegistry.get_item(osystem, default=None)
+    if osystem_obj is not None:
+        arch, subarch = architecture.split('/')
+        purposes = osystem_obj.get_boot_image_purposes(arch, subarch,
+                                                       distro_series, '*')
+        if "ephemeral" in purposes:
+            return hwe_kernel
+
     # If we're not deploying Ubuntu we are just setting the kernel to be used
     # during deployment
     if osystem != "ubuntu":

=== modified file 'src/provisioningserver/boot/pxe.py'
--- src/provisioningserver/boot/pxe.py	2016-12-07 12:46:14 +0000
+++ src/provisioningserver/boot/pxe.py	2017-01-31 22:50:18 +0000
@@ -26,6 +26,7 @@
     atomic_copy,
     atomic_symlink,
 )
+import tempita
 
 
 maaslog = get_maas_logger('pxe')
@@ -113,8 +114,11 @@
         template = self.get_template(
             kernel_params.purpose, kernel_params.arch,
             kernel_params.subarch)
+        kernel_params.mac = extra.get('mac', '')
         namespace = self.compose_template_namespace(kernel_params)
-        return BytesReader(template.substitute(namespace).encode("utf-8"))
+        step1 = template.substitute(namespace)
+        return BytesReader(tempita.Template(step1).substitute(namespace)
+                           .encode("utf-8"))
 
     def _link_simplestream_bootloaders(self, stream_path, destination):
         super()._link_simplestream_bootloaders(stream_path, destination)

=== modified file 'src/provisioningserver/boot/tftppath.py'
--- src/provisioningserver/boot/tftppath.py	2016-09-30 19:08:51 +0000
+++ src/provisioningserver/boot/tftppath.py	2017-01-31 22:50:18 +0000
@@ -161,7 +161,8 @@
         image = dict(
             osystem=osystem, architecture=arch, subarchitecture=subarch,
             release=release, label=label, purpose=purpose)
-        if purpose == BOOT_IMAGE_PURPOSE.XINSTALL:
+        if purpose == BOOT_IMAGE_PURPOSE.XINSTALL \
+                or purpose == BOOT_IMAGE_PURPOSE.EPHEMERAL:
             xinstall_path, xinstall_type = osystem_obj.get_xinstall_parameters(
                 arch, subarch, release, label)
             image['xinstall_path'] = xinstall_path

=== modified file 'src/provisioningserver/drivers/osystem/__init__.py'
--- src/provisioningserver/drivers/osystem/__init__.py	2016-09-12 21:33:05 +0000
+++ src/provisioningserver/drivers/osystem/__init__.py	2017-01-31 22:50:18 +0000
@@ -32,7 +32,8 @@
     DISKLESS = 'diskless'
     #: Bootloader for enlistment, commissioning, and deployment
     BOOTLOADER = 'bootloader'
-
+    #: Usable for ephemeral boots
+    EPHEMERAL = 'ephemeral'
 
 # A cluster-side representation of a Node, relevant to the osystem code,
 # with only minimal fields.
@@ -207,6 +208,7 @@
 from provisioningserver.drivers.osystem.custom import CustomOS
 from provisioningserver.drivers.osystem.windows import WindowsOS
 from provisioningserver.drivers.osystem.suse import SUSEOS
+from provisioningserver.drivers.osystem.caringo import CaringoOS
 
 builtin_osystems = [
     UbuntuOS(),
@@ -215,6 +217,7 @@
     CustomOS(),
     WindowsOS(),
     SUSEOS(),
+    CaringoOS(),
     ]
 for osystem in builtin_osystems:
     OperatingSystemRegistry.register_item(osystem.name, osystem)

=== added file 'src/provisioningserver/drivers/osystem/caringo.py'
--- src/provisioningserver/drivers/osystem/caringo.py	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/drivers/osystem/caringo.py	2017-01-31 22:50:18 +0000
@@ -0,0 +1,45 @@
+# Copyright 2014-2015 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Operating System class used for custom images."""
+
+__all__ = [
+    "CaringoOS",
+    ]
+
+from provisioningserver.drivers.osystem import (
+    BOOT_IMAGE_PURPOSE,
+    OperatingSystem,
+)
+
+
+class CaringoOS(OperatingSystem):
+    """Custom operating system."""
+
+    name = "caringo"
+    title = "Caringo"
+
+    def get_boot_image_purposes(self, arch, subarch, release, label):
+        """Gets the purpose of each boot image."""
+        return [BOOT_IMAGE_PURPOSE.EPHEMERAL]
+
+    def is_release_supported(self, release):
+        """Return True when the release is supported, False otherwise."""
+        # All release are supported, since the user uploaded it.
+        return True
+
+    def get_default_release(self):
+        """Gets the default release to use when a release is not
+        explicit."""
+        # No default for this OS.
+        return ""
+
+    def get_release_title(self, release):
+        """Return the title for the given release."""
+        # Return the same name, since the cluster does not know about the
+        # title of the image. The region will fix the title for the UI.
+        return release
+
+    def get_xinstall_parameters(self, arch, subarch, release, label):
+        """Returns the xinstall image name and type for given image."""
+        return "root-tgz", "tgz"

=== modified file 'src/provisioningserver/kernel_opts.py'
--- src/provisioningserver/kernel_opts.py	2016-12-20 18:03:49 +0000
+++ src/provisioningserver/kernel_opts.py	2017-01-31 22:50:18 +0000
@@ -121,7 +121,7 @@
 
 def compose_purpose_opts(params):
     """Return the list of the purpose-specific kernel options."""
-    if params.purpose in ["commissioning", "xinstall", "enlist"]:
+    if params.purpose in ["commissioning", "xinstall", "enlist", "ephemeral"]:
         # These are kernel parameters read by the ephemeral environment.
         tname = prefix_target_name(
             get_ephemeral_name(

=== modified file 'src/provisioningserver/rackdservices/tftp.py'
--- src/provisioningserver/rackdservices/tftp.py	2016-12-07 12:46:14 +0000
+++ src/provisioningserver/rackdservices/tftp.py	2017-01-31 22:50:18 +0000
@@ -20,6 +20,7 @@
     get_remote_mac,
 )
 from provisioningserver.drivers import ArchitectureRegistry
+from provisioningserver.drivers.osystem import OperatingSystemRegistry
 from provisioningserver.events import (
     EVENT_TYPES,
     send_node_event_mac_address,
@@ -182,13 +183,28 @@
 
         Calls `MarkNodeFailed` for the machine if its a known machine.
         """
+        is_ephemeral = False
+        try:
+            osystem_obj = OperatingSystemRegistry.get_item(params['osystem'],
+                                                           default=None)
+            purposes = osystem_obj \
+                .get_boot_image_purposes(params["arch"], params["subarch"],
+                                         params.get("release", ""),
+                                         params.get("label", ""))
+            if "ephemeral" in purposes:
+                is_ephemeral = True
+        except:
+            pass
+
         system_id = params.pop("system_id", None)
-        if params["purpose"] == "local":
+        if params["purpose"] == "local" and not is_ephemeral:
             # Local purpose doesn't use a boot image so jsut set the label
             # to "local", but this value will no be used.
             params["label"] = "local"
             return params
         else:
+            if params["purpose"] == "local" and is_ephemeral:
+                params["purpose"] = "ephemeral"
             boot_image = get_boot_image(params)
             if boot_image is None:
                 # No matching boot image.

=== added file 'src/provisioningserver/templates/pxe/config.ephemeral.amd64.generic.template'
--- src/provisioningserver/templates/pxe/config.ephemeral.amd64.generic.template	1970-01-01 00:00:00 +0000
+++ src/provisioningserver/templates/pxe/config.ephemeral.amd64.generic.template	2017-01-31 22:50:18 +0000
@@ -0,0 +1,8 @@
+DEFAULT execute
+
+LABEL execute
+  SAY booting ephemeral image...
+  SAY extra={{ kernel_params.extra_opts }}
+  KERNEL {{kernel_params | kernel_path }}
+  APPEND initrd={{kernel_params | initrd_path }} {{ kernel_params.extra_opts }} maas_url={{kernel_params.preseed_url }}
+