Merge lp:~blake-rouse/maas/remove-pxeconfig into lp:~maas-committers/maas/trunk

[Blake Rouse]

Remove pxeconfig API as its not longer used. Has been replaced by the GetBootConfig RPC call.

[Blake Rouse (blake-rouse)]

All red!!!!

[Andres Rodriguez (andreserl)]

lgtm!

review: Approve

[Gavin Panella (allenap)]

I count two lines of green ;)

Nice stuff!

[Blake Rouse (blake-rouse)]

Now its all red. ;-)

=== removed file 'src/maasserver/api/pxeconfig.py'
--- src/maasserver/api/pxeconfig.py	2016-03-09 06:54:33 +0000
+++ src/maasserver/api/pxeconfig.py	1970-01-01 00:00:00 +0000
@@ -1,340 +0,0 @@
-# Copyright 2014-2016 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""API handler: `pxeconfig`."""
-
-__all__ = [
-    'pxeconfig',
-    ]
-
-import http.client
-import json
-
-from crochet import TimeoutError
-from django.http import HttpResponse
-from maasserver import logger
-from maasserver.api.utils import (
-    get_mandatory_param,
-    get_optional_param,
-)
-from maasserver.clusterrpc.boot_images import get_boot_images_for
-from maasserver.enum import INTERFACE_TYPE
-from maasserver.models import (
-    BootResource,
-    Config,
-    Event,
-    RackController,
-)
-from maasserver.models.interface import (
-    Interface,
-    PhysicalInterface,
-)
-from maasserver.preseed import (
-    compose_enlistment_preseed_url,
-    compose_preseed_url,
-)
-from maasserver.server_address import get_maas_facing_server_address
-from maasserver.third_party_drivers import get_third_party_driver
-from maasserver.utils import find_rack_controller
-from maasserver.utils.orm import get_one
-from provisioningserver.events import EVENT_TYPES
-from provisioningserver.kernel_opts import KernelParameters
-from provisioningserver.rpc.exceptions import NoConnectionsAvailable
-
-
-def find_rack_controller_for_pxeconfig_request(request):
-    """Find the rack controller responsible for a `pxeconfig` request.
-
-    Looks for the `rackcontroller_id` parameter in the request.  If there is
-    none, figures it out based on the requesting IP as a compatibility
-    measure.  In that case, the result may be incorrect.
-    """
-    rackcontroller_id = request.GET.get('rackcontroller_id', None)
-    if rackcontroller_id is None:
-        return find_rack_controller(request)
-    else:
-        return RackController.objects.get(system_id=rackcontroller_id)
-
-
-def get_node_from_mac_string(mac_string):
-    """Get a Node object from a MAC address string.
-
-    Returns a Node object or None if no node with the given MAC address exists.
-
-    :param mac_string: MAC address string in the form "12-34-56-78-9a-bc"
-    :return: Node object or None
-    """
-    if mac_string is None:
-        return None
-    interface = get_one(
-        Interface.objects.filter(
-            type=INTERFACE_TYPE.PHYSICAL, mac_address=mac_string))
-    return interface.node if interface else None
-
-
-def get_boot_image(
-        rack_controller, osystem, architecture, subarchitecture, series,
-        purpose):
-    """Obtain the first available boot image for this rack controller for the
-    given osystem, architecture, subarchitecute, series, and purpose."""
-    # When local booting a node we put it through a PXE cycle. In
-    # this case it requests a purpose of "local" when looking for
-    # boot images.  To avoid unnecessary work, we can shortcut that
-    # here and just return None right away.
-    if purpose == "local":
-        return None
-
-    try:
-        images = get_boot_images_for(
-            rack_controller, osystem, architecture, subarchitecture, series)
-    except (NoConnectionsAvailable, TimeoutError):
-        logger.error(
-            "Unable to identify boot image for (%s/%s/%s/%s/%s): "
-            "no RPC connection to rack controller '%s'",
-            osystem, architecture, subarchitecture, series, purpose,
-            rack_controller.hostname)
-        return None
-    for image in images:
-        # get_boot_images_for returns all images that match the subarchitecure
-        # and its supporting subarches. Only want to return the image with
-        # the exact subarchitecture.
-        if (image['subarchitecture'] == subarchitecture and
-                image['purpose'] == purpose):
-            return image
-    logger.error(
-        "Unable to identify boot image for (%s/%s/%s/%s/%s): "
-        "rack controller '%s' does not have matching boot image.",
-        osystem, architecture, subarchitecture, series, purpose,
-        rack_controller.hostname)
-    return None
-
-
-# XXX newell 2014-10-01 bug=1376489: Currently logging the pxe
-# request for the given boot purpose here. It would be better to
-# someday fix this to create the log entries when the file
-# transfer completes, rather than when we receive the first
-# (and potentially duplicate) packet of the request.
-def event_log_pxe_request(node, purpose):
-    """Log PXE request to node's event log."""
-    options = {
-        'commissioning': "commissioning",
-        'xinstall': "curtin install",
-        'install': "d-i install",
-        'local': "local boot",
-        'poweroff': "power off",
-    }
-    Event.objects.create_node_event(
-        system_id=node.system_id, event_type=EVENT_TYPES.NODE_PXE_REQUEST,
-        event_description=options[purpose])
-
-
-DEFAULT_ARCH = 'i386'
-
-
-def pxeconfig(request):
-    """Get the PXE configuration given a node's details.
-
-    Returns a JSON object corresponding to a
-    :class:`provisioningserver.kernel_opts.KernelParameters` instance.
-
-    This is now fairly decoupled from pxelinux's TFTP filename encoding
-    mechanism, with one notable exception. Call this function with (mac, arch,
-    subarch) and it will do the right thing. If details it needs are missing
-    (ie. arch/subarch missing when the MAC is supplied but unknown), then it
-    will as an exception return an HTTP NO_CONTENT (204) in the expectation
-    that this will be translated to a TFTP file not found and pxelinux (or an
-    emulator) will fall back to default-<arch>-<subarch> (in the case of an
-    alternate architecture emulator) or just straight to default (in the case
-    of native pxelinux on i386 or amd64). See bug 1041092 for details and
-    discussion.
-
-    :param mac: MAC address to produce a boot configuration for.
-    :param arch: Architecture name (in the pxelinux namespace, eg. 'arm' not
-        'armhf').
-    :param subarch: Subarchitecture name (in the pxelinux namespace).
-    :param local: The IP address of the cluster controller.
-    :param remote: The IP address of the booting node.
-    :param rackcontroller_id: system_id of the rackcontroller responsible for
-        this node. If omitted, the call will attempt to figure it out based on
-        the requesting IP address, for compatibility.  Passing
-        `rackcontroller_id` is preferred.
-    """
-    request_mac = request.GET.get('mac', None)
-    cluster_ip = get_mandatory_param(request.GET, "local")
-    bios_boot_method = request.GET.get('bios_boot_method', None)
-    node = get_node_from_mac_string(request_mac)
-
-    if node is not None:
-        node_needs_saving = False
-
-        # Only update the booting interface for the node if it has
-        # changed.
-        if (node.boot_interface is None or
-                node.boot_interface.mac_address != request_mac):
-            node.boot_interface = PhysicalInterface.objects.get(
-                mac_address=request_mac)
-            node_needs_saving = True
-
-        # Update the last IP address the cluster booted from.
-        if (node.boot_cluster_ip is None or
-                node.boot_cluster_ip != cluster_ip):
-            node.boot_cluster_ip = cluster_ip
-            node_needs_saving = True
-
-        # Only update the bios boot method if its changed.
-        if node.bios_boot_method != bios_boot_method:
-            node.bios_boot_method = bios_boot_method
-            node_needs_saving = True
-
-        if node_needs_saving:
-            node.save()
-
-    if node is None or node.get_boot_purpose() == "commissioning":
-        osystem = Config.objects.get_config('commissioning_osystem')
-        series = Config.objects.get_config('commissioning_distro_series')
-    else:
-        osystem = node.get_osystem()
-        series = node.get_distro_series()
-
-    rack_controller = find_rack_controller_for_pxeconfig_request(request)
-    if node:
-        arch, subarch = node.architecture.split('/')
-        preseed_url = compose_preseed_url(node, rack_controller)
-        hostname = node.hostname
-        domain = node.domain.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
-        elif(subarch == "generic" and
-             node.get_boot_purpose() == "commissioning" and
-             node.min_hwe_kernel):
-            subarch = node.min_hwe_kernel
-    else:
-        preseed_url = compose_enlistment_preseed_url(
-            rack_controller=rack_controller)
-        hostname = 'maas-enlist'
-        domain = 'local'
-
-        arch = get_optional_param(request.GET, 'arch')
-        if arch is None:
-            if 'mac' in request.GET:
-                # Request was pxelinux.cfg/01-<mac>, so attempt fall back
-                # to pxelinux.cfg/default-<arch>-<subarch> for arch detection.
-                return HttpResponse(status=int(http.client.NO_CONTENT))
-            else:
-                # Look in BootResource for an resource that actually exists for
-                # the current series. If nothing is found, fall back to i386
-                # like we used to. LP #1181334
-                resource = (
-                    BootResource.objects.get_default_commissioning_resource(
-                        osystem, series))
-                if resource is None:
-                    arch = DEFAULT_ARCH
-                else:
-                    arch, _ = resource.split_arch()
-
-        default_min_hwe_kernel = Config.objects.get_config(
-            'default_min_hwe_kernel')
-        if default_min_hwe_kernel:
-            subarch = get_optional_param(
-                request.GET, 'subarch', default_min_hwe_kernel)
-        else:
-            subarch = get_optional_param(
-                request.GET, 'subarch', 'generic')
-
-    # If we are booting with "xinstall", then we should always return the
-    # commissioning operating system and distro_series.
-    if node is None:
-        purpose = "commissioning"  # enlistment
-    else:
-        purpose = node.get_boot_purpose()
-        event_log_pxe_request(node, purpose)
-
-    # Use only the commissioning osystem and series, for operating systems
-    # other than Ubuntu. As Ubuntu supports HWE kernels, and needs to use
-    # that kernel to perform the installation.
-    if purpose == "xinstall" and osystem != 'ubuntu':
-        osystem = Config.objects.get_config('commissioning_osystem')
-        series = Config.objects.get_config('commissioning_distro_series')
-
-    if purpose == 'poweroff':
-        # In order to power the node off, we need to get it booted in the
-        # commissioning environment and issue a `poweroff` command.
-        boot_purpose = 'commissioning'
-    else:
-        boot_purpose = purpose
-
-    # We use as our default label the label of the most recent image for
-    # the criteria we've assembled above. If there is no latest image
-    # (which should never happen in reality but may happen in tests), we
-    # fall back to using 'no-such-image' as our default.
-    latest_image = get_boot_image(
-        rack_controller, osystem, arch, subarch, series, boot_purpose)
-    if latest_image is None:
-        # XXX 2014-03-18 gmb bug=1294131:
-        #     We really ought to raise an exception here so that client
-        #     and server can handle it according to their needs. At the
-        #     moment, though, that breaks too many tests in awkward
-        #     ways.
-        latest_label = 'no-such-image'
-    else:
-        latest_label = latest_image['label']
-        # subarch may be different from the request because newer images
-        # support older hardware enablement, e.g. trusty/generic
-        # supports trusty/hwe-s. We must override the subarch to the one
-        # on the image otherwise the config path will be wrong if
-        # get_latest_image() returned an image with a different subarch.
-        subarch = latest_image['subarchitecture']
-    label = get_optional_param(request.GET, 'label', latest_label)
-
-    if node is not None:
-        # We don't care if the kernel opts is from the global setting or a tag,
-        # just get the options
-        _, effective_kernel_opts = node.get_effective_kernel_options()
-
-        # Add any extra options from a third party driver.
-        use_driver = Config.objects.get_config('enable_third_party_drivers')
-        if use_driver:
-            driver = get_third_party_driver(node)
-            driver_kernel_opts = driver.get('kernel_opts', '')
-
-            combined_opts = ('%s %s' % (
-                '' if effective_kernel_opts is None else effective_kernel_opts,
-                driver_kernel_opts)).strip()
-            if len(combined_opts):
-                extra_kernel_opts = combined_opts
-            else:
-                extra_kernel_opts = None
-        else:
-            extra_kernel_opts = effective_kernel_opts
-    else:
-        # If there's no node defined then we must be enlisting here, but
-        # we still need to return the global kernel options.
-        extra_kernel_opts = Config.objects.get_config("kernel_opts")
-
-    server_address = get_maas_facing_server_address(
-        rack_controller=rack_controller)
-
-    # If the node is enlisting and the arch is the default arch (i386),
-    # use the dedicated enlistment template which performs architecture
-    # detection.
-    if node is None and arch == DEFAULT_ARCH:
-        boot_purpose = "enlist"
-
-    params = KernelParameters(
-        osystem=osystem, arch=arch, subarch=subarch, release=series,
-        label=label, purpose=boot_purpose, hostname=hostname, domain=domain,
-        preseed_url=preseed_url, log_host=server_address,
-        fs_host=cluster_ip, extra_opts=extra_kernel_opts)
-
-    return HttpResponse(
-        json.dumps(params._asdict()),
-        content_type="application/json")

=== removed file 'src/maasserver/api/tests/test_pxeconfig.py'
--- src/maasserver/api/tests/test_pxeconfig.py	2016-02-29 19:21:03 +0000
+++ src/maasserver/api/tests/test_pxeconfig.py	1970-01-01 00:00:00 +0000
@@ -1,712 +0,0 @@
-# Copyright 2013-2016 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""Tests for PXE configuration retrieval from the API."""
-
-__all__ = []
-
-import http.client
-import json
-from unittest import skip
-
-from crochet import TimeoutError
-from django.conf import settings
-from django.core.urlresolvers import reverse
-from django.test.client import RequestFactory
-from maasserver import (
-    preseed as preseed_module,
-    server_address,
-)
-from maasserver.api import pxeconfig as pxeconfig_module
-from maasserver.api.pxeconfig import (
-    event_log_pxe_request,
-    find_rack_controller_for_pxeconfig_request,
-    get_boot_image,
-)
-from maasserver.clusterrpc.testing.boot_images import make_rpc_boot_image
-from maasserver.enum import (
-    BOOT_RESOURCE_TYPE,
-    INTERFACE_TYPE,
-    NODE_STATUS,
-)
-from maasserver.models import (
-    Config,
-    Event,
-    Interface,
-    Node,
-)
-from maasserver.preseed import (
-    compose_enlistment_preseed_url,
-    compose_preseed_url,
-)
-from maasserver.testing.architecture import make_usable_architecture
-from maasserver.testing.config import RegionConfigurationFixture
-from maasserver.testing.factory import factory
-from maasserver.testing.testcase import MAASServerTestCase
-from maasserver.utils.orm import reload_object
-from maastesting.fakemethod import FakeMethod
-from maastesting.matchers import (
-    MockCalledOnceWith,
-    MockNotCalled,
-)
-from mock import sentinel
-from netaddr import IPNetwork
-from provisioningserver import kernel_opts
-from provisioningserver.kernel_opts import KernelParameters
-from provisioningserver.rpc.exceptions import NoConnectionsAvailable
-from testtools.matchers import (
-    Contains,
-    ContainsAll,
-    Equals,
-    Is,
-    MatchesListwise,
-    StartsWith,
-)
-
-
-class TestGetBootImage(MAASServerTestCase):
-
-    def setUp(self):
-        super().setUp()
-        self.rackcontroller = factory.make_RackController()
-
-    def test__returns_None_when_connection_unavailable(self):
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').side_effect = NoConnectionsAvailable
-        self.assertEqual(
-            None,
-            get_boot_image(
-                self.rackcontroller, sentinel.osystem,
-                sentinel.architecture, sentinel.subarchitecture,
-                sentinel.series, sentinel.purpose))
-
-    def test__returns_None_when_timeout_error(self):
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').side_effect = TimeoutError
-        self.assertEqual(
-            None,
-            get_boot_image(
-                self.rackcontroller, sentinel.osystem,
-                sentinel.architecture, sentinel.subarchitecture,
-                sentinel.series, sentinel.purpose))
-
-    def test__returns_matching_image(self):
-        subarch = factory.make_name('subarch')
-        purpose = factory.make_name('purpose')
-        boot_image = make_rpc_boot_image(
-            subarchitecture=subarch, purpose=purpose)
-        other_images = [make_rpc_boot_image() for _ in range(3)]
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').return_value = other_images + [boot_image]
-        self.assertEqual(
-            boot_image,
-            get_boot_image(
-                self.rackcontroller, sentinel.osystem,
-                sentinel.architecture, subarch,
-                sentinel.series, purpose))
-
-    def test__returns_None_on_no_matching_image(self):
-        subarch = factory.make_name('subarch')
-        purpose = factory.make_name('purpose')
-        other_images = [make_rpc_boot_image() for _ in range(3)]
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').return_value = other_images
-        self.assertEqual(
-            None,
-            get_boot_image(
-                self.rackcontroller, sentinel.osystem,
-                sentinel.architecture, subarch,
-                sentinel.series, purpose))
-
-    def test__returns_None_immediately_if_purpose_is_local(self):
-        self.patch(pxeconfig_module, 'get_boot_images_for')
-        self.expectThat(
-            get_boot_image(
-                self.rackcontroller, sentinel.osystem,
-                sentinel.architecture, sentinel.subarchitecture,
-                sentinel.series, "local"),
-            Is(None))
-        self.expectThat(pxeconfig_module.get_boot_images_for, MockNotCalled())
-
-
-class TestPXEConfigAPI(MAASServerTestCase):
-    def setUp(self):
-        super(TestPXEConfigAPI, self).setUp()
-        self.useFixture(RegionConfigurationFixture())
-
-    def get_default_params(self, rack_controller=None):
-        if rack_controller is None:
-            rack_controller = factory.make_RackController()
-        return {
-            "local": factory.make_ipv4_address(),
-            "remote": factory.make_ipv4_address(),
-            "rackcontroller_id": rack_controller.system_id,
-            }
-
-    def get_mac_params(self):
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.DEPLOYING)
-        arch, subarch = node.split_arch()
-        image = make_rpc_boot_image(
-            osystem=node.get_osystem(), release=node.get_distro_series(),
-            architecture=arch, subarchitecture=subarch,
-            purpose='install')
-        self.patch(
-            preseed_module,
-            'get_boot_images_for').return_value = [image]
-        params = self.get_default_params()
-        params['mac'] = node.get_boot_interface().mac_address
-        return params
-
-    def get_pxeconfig(self, params=None):
-        """Make a request to `pxeconfig`, and return its response dict."""
-        if params is None:
-            params = self.get_default_params()
-        response = self.client.get(reverse('pxeconfig'), params)
-        return json.loads(response.content.decode(settings.DEFAULT_CHARSET))
-
-    @skip("XXX: GavinPanella 2016-02-24 bug=1549206: Fails spuriously.")
-    def test_pxeconfig_returns_json(self):
-        params = self.get_default_params()
-        response = self.client.get(
-            reverse('pxeconfig'), params)
-        self.assertThat(
-            (
-                response.status_code,
-                response['Content-Type'],
-                response.content,
-                response.content.decode(settings.DEFAULT_CHARSET),
-            ),
-            MatchesListwise(
-                (
-                    Equals(http.client.OK),
-                    Equals("application/json"),
-                    StartsWith(b'{'),
-                    Contains('arch'),
-                )),
-            response)
-
-    def test_pxeconfig_returns_all_kernel_parameters(self):
-        params = self.get_default_params()
-        self.assertThat(
-            self.get_pxeconfig(params),
-            ContainsAll(KernelParameters._fields))
-
-    def test_pxeconfig_returns_success_for_known_node(self):
-        params = self.get_mac_params()
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(http.client.OK, response.status_code)
-
-    def test_pxeconfig_returns_no_content_for_unknown_node(self):
-        params = dict(
-            mac=factory.make_mac_address(delimiter='-'),
-            local=factory.make_ipv4_address())
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(http.client.NO_CONTENT, response.status_code)
-
-    def test_pxeconfig_returns_success_for_detailed_but_unknown_node(self):
-        architecture = make_usable_architecture(self)
-        arch, subarch = architecture.split('/')
-        rack = factory.make_RackController()
-        params = dict(
-            self.get_default_params(),
-            mac=factory.make_mac_address(delimiter='-'),
-            arch=arch,
-            subarch=subarch,
-            rackcontroller_id=rack.system_id)
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(http.client.OK, response.status_code)
-
-    def test_pxeconfig_returns_global_kernel_params_for_enlisting_node(self):
-        # An 'enlisting' node means it looks like a node with details but we
-        # don't know about it yet.  It should still receive the global
-        # kernel options.
-        value = factory.make_string()
-        Config.objects.set_config("kernel_opts", value)
-        architecture = make_usable_architecture(self)
-        arch, subarch = architecture.split('/')
-        rack = factory.make_RackController()
-        params = dict(
-            self.get_default_params(),
-            mac=factory.make_mac_address(delimiter='-'),
-            arch=arch,
-            subarch=subarch,
-            rackcontroller_id=rack.system_id)
-        response = self.client.get(reverse('pxeconfig'), params)
-        response_dict = json.loads(
-            response.content.decode(settings.DEFAULT_CHARSET))
-        self.assertEqual(value, response_dict['extra_opts'])
-
-    def test_pxeconfig_uses_present_boot_image(self):
-        osystem = Config.objects.get_config('commissioning_osystem')
-        release = Config.objects.get_config('commissioning_distro_series')
-        resource_name = '%s/%s' % (osystem, release)
-        factory.make_usable_boot_resource(
-            rtype=BOOT_RESOURCE_TYPE.SYNCED,
-            name=resource_name, architecture='amd64/generic')
-        params = self.get_default_params()
-        params_out = self.get_pxeconfig(params)
-        self.assertEqual("amd64", params_out["arch"])
-
-    def test_pxeconfig_defaults_to_i386_for_default(self):
-        # As a lowest-common-denominator, i386 is chosen when the node is not
-        # yet known to MAAS.
-        expected_arch = tuple(
-            make_usable_architecture(
-                self, arch_name="i386", subarch_name="generic").split("/"))
-        params = self.get_default_params()
-        params_out = self.get_pxeconfig(params)
-        observed_arch = params_out["arch"], params_out["subarch"]
-        self.assertEqual(expected_arch, observed_arch)
-
-    def test_pxeconfig_uses_fixed_hostname_for_enlisting_node(self):
-        params = self.get_default_params()
-        self.assertEqual(
-            'maas-enlist', self.get_pxeconfig(params).get('hostname'))
-
-    def test_pxeconfig_uses_local_domain_for_enlisting_node(self):
-        params = self.get_default_params()
-        self.assertEqual(
-            "local",
-            self.get_pxeconfig(params).get('domain'))
-
-    def test_pxeconfig_splits_domain_from_node_hostname(self):
-        host = factory.make_name('host')
-        domainname = factory.make_name('domain')
-        domain = factory.make_Domain(name=domainname)
-        full_hostname = '.'.join([host, domainname])
-        node = factory.make_Node_with_Interface_on_Subnet(
-            hostname=full_hostname, domain=domain)
-        interface = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = interface.mac_address
-        pxe_config = self.get_pxeconfig(params)
-        self.assertEqual(host, pxe_config.get('hostname'))
-        self.assertNotIn(domain, pxe_config.values())
-
-    def test_pxeconfig_uses_domain_for_node(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        interface = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = interface.mac_address
-        self.assertEqual(
-            node.domain.name,
-            self.get_pxeconfig(params).get('domain'))
-
-    def get_without_param(self, param):
-        """Request a `pxeconfig()` response, but omit `param` from request."""
-        params = self.get_params()
-        del params[param]
-        return self.client.get(reverse('pxeconfig'), params)
-
-    def silence_get_ephemeral_name(self):
-        # Silence `get_ephemeral_name` to avoid having to fetch the
-        # ephemeral name from the filesystem.
-        self.patch(
-            kernel_opts, 'get_ephemeral_name',
-            FakeMethod(result=factory.make_string()))
-
-    def test_pxeconfig_has_enlistment_preseed_url_for_default(self):
-        self.silence_get_ephemeral_name()
-        params = self.get_default_params()
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(
-            compose_enlistment_preseed_url(),
-            json.loads(response.content.decode(
-                settings.DEFAULT_CHARSET))["preseed_url"])
-
-    def test_pxeconfig_enlistment_preseed_url_detects_request_origin(self):
-        self.silence_get_ephemeral_name()
-        hostname = factory.make_hostname()
-        rack_url = 'http://%s' % hostname
-        network = IPNetwork("10.1.1/24")
-        ip = factory.pick_ip_in_network(network)
-        self.patch(server_address, 'resolve_hostname').return_value = {ip}
-        rack_controller = factory.make_RackController(url=rack_url)
-        subnet = factory.make_Subnet(cidr=str(network.cidr), dhcp_on=True)
-        subnet.vlan.primary_rack = rack_controller
-        subnet.vlan.save()
-        params = self.get_default_params(rack_controller)
-        del params['rackcontroller_id']
-
-        # Simulate that the request originates from ip by setting
-        # 'REMOTE_ADDR'.
-        response = self.client.get(
-            reverse('pxeconfig'), params, REMOTE_ADDR=ip)
-        self.assertThat(
-            json.loads(
-                response.content.decode(
-                    settings.DEFAULT_CHARSET))["preseed_url"],
-            StartsWith(rack_url))
-
-    def test_pxeconfig_enlistment_log_host_url_detects_request_origin(self):
-        self.silence_get_ephemeral_name()
-        hostname = factory.make_hostname()
-        rack_url = 'http://%s' % hostname
-        network = IPNetwork("10.1.1/24")
-        ip = factory.pick_ip_in_network(network)
-        mock = self.patch(server_address, 'resolve_hostname')
-        mock.return_value = {ip}
-        rack_controller = factory.make_RackController(url=rack_url)
-        subnet = factory.make_Subnet(cidr=str(network.cidr), dhcp_on=True)
-        subnet.vlan.primary_rack = rack_controller
-        subnet.vlan.save()
-        params = self.get_default_params(rack_controller)
-        del params['rackcontroller_id']
-
-        # Simulate that the request originates from ip by setting
-        # 'REMOTE_ADDR'.
-        response = self.client.get(
-            reverse('pxeconfig'), params, REMOTE_ADDR=ip)
-        self.assertEqual(
-            (ip, hostname),
-            (json.loads(
-                response.content.decode(
-                    settings.DEFAULT_CHARSET))["log_host"],
-             mock.call_args[0][0]))
-
-    def test_pxeconfig_enlistment_checks_default_min_hwe_kernel(self):
-        params = self.get_default_params()
-        params['arch'] = 'armhf'
-        Config.objects.set_config('default_min_hwe_kernel', 'hwe-v')
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(
-            "hwe-v",
-            json.loads(
-                response.content.decode(settings.DEFAULT_CHARSET))["subarch"])
-
-    def test_pxeconfig_has_preseed_url_for_known_node(self):
-        rack_controller = factory.make_RackController()
-        params = self.get_mac_params()
-        params["rackcontroller_id"] = rack_controller.system_id
-        node = Interface.objects.get(mac_address=params['mac']).node
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(
-            compose_preseed_url(node, rack_controller),
-            json.loads(
-                response.content.decode(
-                    settings.DEFAULT_CHARSET))["preseed_url"])
-
-    def test_find_rack_for_pxeconfig_request_uses_rack_system_id(self):
-        params = self.get_mac_params()
-        rack = factory.make_RackController()
-        params['rackcontroller_id'] = rack.system_id
-        request = RequestFactory().get(reverse('pxeconfig'), params)
-        self.assertEqual(
-            rack,
-            find_rack_controller_for_pxeconfig_request(request))
-
-    def test_preseed_url_for_known_node_uses_rack_url(self):
-        rack_url = 'http://%s' % factory.make_name('host')
-        network = IPNetwork("10.1.1/24")
-        ip = factory.pick_ip_in_network(network)
-        self.patch(server_address, 'resolve_hostname').return_value = {ip}
-        rack_controller = factory.make_RackController(url=rack_url)
-        node = factory.make_Node_with_Interface_on_Subnet(
-            primary_rack=rack_controller)
-        params = self.get_default_params()
-        params['mac'] = str(node.get_boot_interface().mac_address)
-        params['rackcontroller_id'] = rack_controller.system_id
-
-        # Simulate that the request originates from ip by setting
-        # 'REMOTE_ADDR'.
-        response = self.client.get(
-            reverse('pxeconfig'), params, REMOTE_ADDR=ip)
-        self.assertThat(
-            json.loads(
-                response.content.decode(
-                    settings.DEFAULT_CHARSET))["preseed_url"],
-            StartsWith(rack_url))
-
-    def test_pxeconfig_uses_boot_purpose_enlistment(self):
-        # test that purpose is set to "commissioning" for
-        # enlistment (when node is None).
-        params = self.get_default_params()
-        params['arch'] = 'armhf'
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(
-            "commissioning",
-            json.loads(
-                response.content.decode(settings.DEFAULT_CHARSET))["purpose"])
-
-    def test_pxeconfig_returns_enlist_config_if_no_architecture_provided(self):
-        params = self.get_default_params()
-        pxe_config = self.get_pxeconfig(params)
-        self.assertEqual('enlist', pxe_config['purpose'])
-
-    def test_pxeconfig_returns_fs_host_as_cluster_controller(self):
-        # The kernel parameter `fs_host` points to the cluster controller
-        # address, which is passed over within the `local` parameter.
-        params = self.get_default_params()
-        kernel_params = KernelParameters(**self.get_pxeconfig(params))
-        self.assertEqual(params["local"], kernel_params.fs_host)
-
-    def test_pxeconfig_returns_extra_kernel_options(self):
-        extra_kernel_opts = factory.make_string()
-        Config.objects.set_config('kernel_opts', extra_kernel_opts)
-        params = self.get_mac_params()
-        pxe_config = self.get_pxeconfig(params)
-        self.assertEqual(extra_kernel_opts, pxe_config['extra_opts'])
-
-    def test_pxeconfig_returns_None_for_extra_kernel_opts(self):
-        params = self.get_mac_params()
-        pxe_config = self.get_pxeconfig(params)
-        self.assertEqual(None, pxe_config['extra_opts'])
-
-    def test_pxeconfig_returns_commissioning_for_insane_state(self):
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.BROKEN)
-        nic = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        pxe_config = self.get_pxeconfig(params)
-        # The 'purpose' of the PXE config is 'commissioning' here
-        # even if the 'purpose' returned by node.get_boot_purpose
-        # is 'poweroff' because MAAS needs to bring the machine
-        # up in a commissioning environment in order to power
-        # the machine down.
-        self.assertEqual('commissioning', pxe_config['purpose'])
-
-    def test_pxeconfig_returns_commissioning_for_ready_node(self):
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.READY)
-        nic = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        pxe_config = self.get_pxeconfig(params)
-        self.assertEqual('commissioning', pxe_config['purpose'])
-
-    def test_pxeconfig_returns_image_subarch_not_node_subarch(self):
-        # In the scenario such as deploying trusty on an hwe-s subarch
-        # node, the code will have fallen back to using trusty's generic
-        # image as per the supported_subarches on the image. However,
-        # pxeconfig needs to make sure the image path refers to the
-        # subarch from the image, rather than the requested one.
-        osystem = 'ubuntu'
-        release = Config.objects.get_config('default_distro_series')
-        rack = factory.make_RackController()
-        generic_image = make_rpc_boot_image(
-            osystem=osystem, release=release,
-            architecture="amd64", subarchitecture="generic",
-            purpose='install')
-        hwe_s_image = make_rpc_boot_image(
-            osystem=osystem, release=release,
-            architecture="amd64", subarchitecture="hwe-s",
-            purpose='install')
-        self.patch(
-            preseed_module,
-            'get_boot_images_for').return_value = [generic_image, hwe_s_image]
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').return_value = [generic_image, hwe_s_image]
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.DEPLOYING,
-            architecture="amd64/hwe-s",
-            primary_rack=rack)
-        params = self.get_default_params()
-        params['rackcontroller_id'] = rack.system_id
-        params['mac'] = node.get_boot_interface().mac_address
-        params['arch'] = "amd64"
-        params['subarch'] = "hwe-s"
-
-        params_out = self.get_pxeconfig(params)
-        self.assertEqual("hwe-s", params_out["subarch"])
-
-    def test_pxeconfig_calls_event_log_pxe_request(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        nic = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        event_log_pxe_request = self.patch_autospec(
-            pxeconfig_module, 'event_log_pxe_request')
-        self.client.get(reverse('pxeconfig'), params)
-        self.assertThat(
-            event_log_pxe_request,
-            MockCalledOnceWith(node, node.get_boot_purpose()))
-
-    def test_event_log_pxe_request_for_known_boot_purpose(self):
-        purposes = [
-            ("commissioning", "commissioning"),
-            ("install", "d-i install"),
-            ("xinstall", "curtin install"),
-            ("local", "local boot"),
-            ("poweroff", "power off")]
-        for purpose, description in purposes:
-            node = factory.make_Node()
-            event_log_pxe_request(node, purpose)
-            self.assertEqual(
-                description,
-                Event.objects.get(node=node).description)
-
-    def test_pxeconfig_sets_boot_interface_when_empty(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        nic = node.get_boot_interface()
-        node.boot_interface = None
-        node.save()
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        self.client.get(reverse('pxeconfig'), params)
-        node = reload_object(node)
-        self.assertEqual(nic, node.boot_interface)
-
-    def test_pxeconfig_updates_boot_interface_when_changed(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        node.boot_interface = node.get_boot_interface()
-        node.save()
-        nic = factory.make_Interface(
-            INTERFACE_TYPE.PHYSICAL, node=node, vlan=node.boot_interface.vlan)
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        self.client.get(reverse('pxeconfig'), params)
-        node = reload_object(node)
-        self.assertEqual(nic, node.boot_interface)
-
-    def test_pxeconfig_doesnt_update_boot_interface_when_same(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        node.boot_interface = node.get_boot_interface()
-        node.save()
-        params = self.get_default_params()
-        params['mac'] = node.boot_interface.mac_address
-        node.boot_cluster_ip = params['local']
-        node.save()
-        mock_save = self.patch(Node, 'save')
-        self.client.get(reverse('pxeconfig'), params)
-        self.assertThat(mock_save, MockNotCalled())
-
-    def test_pxeconfig_sets_boot_cluster_ip_when_empty(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        params = self.get_default_params()
-        params['mac'] = node.get_boot_interface().mac_address
-        self.client.get(reverse('pxeconfig'), params)
-        node = reload_object(node)
-        self.assertEqual(params['local'], node.boot_cluster_ip)
-
-    def test_pxeconfig_updates_boot_cluster_ip_when_changed(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        node.boot_cluster_ip = factory.make_ipv4_address()
-        node.save()
-        params = self.get_default_params()
-        params['mac'] = node.get_boot_interface().mac_address
-        self.client.get(reverse('pxeconfig'), params)
-        node = reload_object(node)
-        self.assertEqual(params['local'], node.boot_cluster_ip)
-
-    def test_pxeconfig_doesnt_update_boot_cluster_ip_when_same(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        node.boot_interface = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = node.boot_interface.mac_address
-        node.boot_cluster_ip = params['local']
-        node.save()
-        mock_save = self.patch(Node, 'save')
-        self.client.get(reverse('pxeconfig'), params)
-        self.assertThat(mock_save, MockNotCalled())
-
-    def test_pxeconfig_updates_bios_boot_method(self):
-        node = factory.make_Node_with_Interface_on_Subnet()
-        nic = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        params['bios_boot_method'] = 'pxe'
-        self.client.get(reverse('pxeconfig'), params)
-        node = reload_object(node)
-        self.assertEqual('pxe', node.bios_boot_method)
-
-    def test_pxeconfig_doesnt_update_bios_boot_method_when_same(self):
-        node = factory.make_Node_with_Interface_on_Subnet(
-            bios_boot_method='uefi')
-        nic = node.get_boot_interface()
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        params['bios_boot_method'] = 'uefi'
-        node.boot_interface = nic
-        node.boot_cluster_ip = params['local']
-        node.save()
-        mock_save = self.patch(Node, 'save')
-        self.client.get(reverse('pxeconfig'), params)
-        self.assertThat(mock_save, MockNotCalled())
-
-    def test_pxeconfig_returns_commissioning_os_series_for_other_oses(self):
-        osystem = Config.objects.get_config('default_osystem')
-        release = Config.objects.get_config('default_distro_series')
-        os_image = make_rpc_boot_image(purpose='xinstall')
-        architecture = '%s/%s' % (
-            os_image['architecture'], os_image['subarchitecture'])
-        self.patch(
-            preseed_module,
-            'get_boot_images_for').return_value = [os_image]
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').return_value = [os_image]
-        rack_controller = factory.make_RackController()
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.DEPLOYING,
-            osystem=os_image['osystem'],
-            distro_series=os_image['release'],
-            architecture=architecture,
-            primary_rack=rack_controller)
-        params = self.get_default_params()
-        params['rackcontroller_id'] = rack_controller.system_id
-        params['mac'] = node.get_boot_interface().mac_address
-        params_out = self.get_pxeconfig(params)
-        self.assertEqual(osystem, params_out["osystem"])
-        self.assertEqual(release, params_out["release"])
-
-    def test_pxeconfig_commissioning_node_uses_min_hwe_kernel(self):
-        node = factory.make_Node_with_Interface_on_Subnet(
-            min_hwe_kernel="hwe-v")
-        nic = node.get_boot_interface()
-        self.patch(Node, 'get_boot_purpose').return_value = "commissioning"
-        params = self.get_default_params()
-        params['mac'] = nic.mac_address
-        response = self.client.get(reverse('pxeconfig'), params)
-        self.assertEqual(
-            "hwe-v",
-            json.loads(
-                response.content.decode(settings.DEFAULT_CHARSET))["subarch"])
-
-    def test_pxeconfig_returns_ubuntu_os_series_for_ubuntu_xinstall(self):
-        ubuntu_image = make_rpc_boot_image(
-            osystem='ubuntu', purpose='xinstall')
-        architecture = '%s/%s' % (
-            ubuntu_image['architecture'], ubuntu_image['subarchitecture'])
-        self.patch(
-            preseed_module,
-            'get_boot_images_for').return_value = [ubuntu_image]
-        self.patch(
-            pxeconfig_module,
-            'get_boot_images_for').return_value = [ubuntu_image]
-        rack_controller = factory.make_RackController()
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.DEPLOYING, osystem='ubuntu',
-            distro_series=ubuntu_image['release'], architecture=architecture,
-            primary_rack=rack_controller)
-        params = self.get_default_params()
-        params['rackcontroller_id'] = rack_controller.system_id
-        params['mac'] = node.get_boot_interface().mac_address
-        params_out = self.get_pxeconfig(params)
-        self.assertEqual(ubuntu_image['release'], params_out["release"])
-
-    def test_pxeconfig_returns_commissioning_os_when_erasing_disks(self):
-        commissioning_osystem = factory.make_name("os")
-        Config.objects.set_config(
-            "commissioning_osystem", commissioning_osystem)
-        commissioning_series = factory.make_name("series")
-        Config.objects.set_config(
-            "commissioning_distro_series", commissioning_series)
-        rack_controller = factory.make_RackController()
-        node = factory.make_Node_with_Interface_on_Subnet(
-            status=NODE_STATUS.DISK_ERASING,
-            osystem=factory.make_name("centos"),
-            distro_series=factory.make_name("release"),
-            primary_rack=rack_controller)
-        params = self.get_default_params()
-        params['rackcontroller_id'] = rack_controller.system_id
-        params['mac'] = node.get_boot_interface().mac_address
-        params_out = self.get_pxeconfig(params)
-        self.assertEqual(commissioning_osystem, params_out['osystem'])
-        self.assertEqual(commissioning_series, params_out['release'])

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2016-03-16 07:19:41 +0000
+++ src/maasserver/models/node.py	2016-03-17 13:36:34 +0000
@@ -2585,7 +2585,7 @@
         """Get the boot interface this node is expected to boot from.
 
         Normally, this will be the boot interface last used in a
-        pxeconfig() API request for the node, as recorded in the
+        GetBootConfig RPC request for the node, as recorded in the
         'boot_interface' property. However, if the node hasn't booted since
         the 'boot_interface' property was added to the Node model, this will
         return the node's first interface instead.

=== modified file 'src/maasserver/urls_api.py'
--- src/maasserver/urls_api.py	2016-02-03 14:34:13 +0000
+++ src/maasserver/urls_api.py	2016-03-17 13:36:34 +0000
@@ -111,7 +111,6 @@
     PartitionHandler,
     PartitionsHandler,
 )
-from maasserver.api.pxeconfig import pxeconfig
 from maasserver.api.rackcontrollers import (
     RackControllerHandler,
     RackControllersHandler,
@@ -292,7 +291,6 @@
     '',
     url(r'doc/$', api_doc, name='api-doc'),
     url(r'describe/$', describe, name='describe'),
-    url(r'pxeconfig/$', pxeconfig, name='pxeconfig'),
     url(r'version/$', version_handler, name='version_handler'),
 )
 

=== modified file 'src/provisioningserver/config.py'
--- src/provisioningserver/config.py	2016-02-10 20:24:35 +0000
+++ src/provisioningserver/config.py	2016-03-17 13:36:34 +0000
@@ -767,11 +767,6 @@
             accept_python=True, if_missing=get_tentative_path(
                 "/var/lib/maas/boot-resources/current")))
 
-    @property
-    def tftp_generator_url(self):
-        """The URL at which to obtain the TFTP options for a node."""
-        return "%s/api/2.0/pxeconfig/" % self.maas_url.rstrip("/")
-
     # GRUB options.
 
     @property

=== modified file 'src/provisioningserver/tests/test_config.py'
--- src/provisioningserver/tests/test_config.py	2016-02-10 20:24:35 +0000
+++ src/provisioningserver/tests/test_config.py	2016-03-17 13:36:34 +0000
@@ -667,26 +667,6 @@
         self.assertEqual({"cluster_uuid": str(example_uuid)}, config.store)
 
 
-class TestClusterConfigurationTFTPGeneratorURL(MAASTestCase):
-    """Tests for `ClusterConfiguration.tftp_generator_url`."""
-
-    def test__is_relative_to_maas_url(self):
-        random_url = factory.make_simple_http_url()
-        self.useFixture(ClusterConfigurationFixture(maas_url=random_url))
-        with ClusterConfiguration.open() as configuration:
-            self.assertEqual(
-                random_url + "/api/2.0/pxeconfig/",
-                configuration.tftp_generator_url)
-
-    def test__strips_trailing_slashes_from_maas_url(self):
-        random_url = factory.make_simple_http_url(path="foobar/")
-        self.useFixture(ClusterConfigurationFixture(maas_url=random_url))
-        with ClusterConfiguration.open() as configuration:
-            self.assertEqual(
-                random_url.rstrip("/") + "/api/2.0/pxeconfig/",
-                configuration.tftp_generator_url)
-
-
 class TestClusterConfigurationGRUBRoot(MAASTestCase):
     """Tests for `ClusterConfiguration.grub_root`."""