Merge lp:~blake-rouse/maas/external-dhcp-probe into lp:~maas-committers/maas/trunk

[Blake Rouse]

Update the external_dhcp field on the VLAN for discovered DHCP servers. Remove code that is no longer be used for DHCP probe.

[Gavin Panella (allenap)]

This looks like a welcome simplification. What's made it possible now?

How is rackd given permission to access the necessary port?

I think you can also remove p.dhcp.detect.process_request() and its imports.

Good stuff though.

review: Needs Information

[Blake Rouse (blake-rouse)]

Thanks for the review. I fixed you inline comment.

Believe it or not the bulk of this code could have been removed back in 1.7. When MAAS was switched from celery to RPC most of this code stopped being used. I have tested this on a installed system and MAAS has permission. Really I didn't change any of the probing code, I just removed what is no longer used.

[Gavin Panella (allenap)]

Tip top.

review: Approve

=== modified file 'Makefile'
--- Makefile	2016-03-28 13:54:47 +0000
+++ Makefile	2016-04-07 13:22:34 +0000
@@ -54,7 +54,6 @@
     bin/buildout \
     bin/database \
     bin/maas \
-    bin/maas-probe-dhcp \
     bin/maas-rack \
     bin/maas-region \
     bin/twistd.rack \
@@ -135,7 +134,7 @@
 	$(buildout) install testing-test
 	@touch --no-create $@
 
-bin/maas-probe-dhcp bin/maas-rack bin/twistd.rack: \
+bin/maas-rack bin/twistd.rack: \
     bin/buildout buildout.cfg versions.cfg setup.py
 	$(buildout) install rack
 	@touch --no-create $@
 
=== modified file 'buildout.cfg'
--- buildout.cfg	2016-03-28 13:54:47 +0000
+++ buildout.cfg	2016-04-07 13:22:34 +0000
@@ -189,13 +189,11 @@
 recipe = zc.recipe.egg
 eggs =
 entry-points =
-  maas-probe-dhcp=provisioningserver.dhcp.probe:main
   maas-rack=provisioningserver.__main__:main
   twistd.rack=twisted.scripts.twistd:run
 extra-paths =
   ${common:extra-paths}
 scripts =
-  maas-probe-dhcp
   maas-rack
   twistd.rack
 initialization =
 
=== modified file 'src/maasserver/rpc/rackcontrollers.py'
--- src/maasserver/rpc/rackcontrollers.py	2016-03-28 13:54:47 +0000
+++ src/maasserver/rpc/rackcontrollers.py	2016-04-07 13:22:34 +0000
@@ -16,10 +16,10 @@
 from maasserver import worker_user
 from maasserver.enum import NODE_TYPE
 from maasserver.models import (
-    Interface,
     Node,
     NodeGroupToRackController,
     RackController,
+    StaticIPAddress,
 )
 from maasserver.models.node import typecast_node
 from maasserver.utils.orm import transactional
@@ -163,52 +163,33 @@
 
 
 @transactional
-def update_foreign_dhcp_ip(cluster_uuid, interface_name, foreign_dhcp_ip):
-    """Update the foreign_dhcp_ip field of a given interface on a cluster.
-
-    Note: We do this through an update, not a read/modify/write.
-    Updating NodeGroupInterface client-side may inadvertently trigger
-    Django signals that cause a rewrite of the DHCP config, plus restart
-    of the DHCP server.  The inadvertent triggering has been known to
-    happen because of race conditions between read/modify/write
-    transactions that were enabled by Django defaulting to, and being
-    designed for, the READ COMMITTED isolation level; the ORM writing
-    back even unmodified fields; and GenericIPAddressField's default
-    value being prone to problems where NULL is sometimes represented as
-    None, sometimes as an empty string, and the difference being enough
-    to convince the signal machinery that these fields have changed when
-    in fact they have not.
-
-    :param cluster_uuid: Cluster's UUID.
-    :param interface_name: The name of the cluster interface on which the
-        foreign DHCP server was (or wasn't) discovered.
-    :param foreign_dhcp_ip: IP address of foreign DCHP server, if any.
-    """
-    # XXX 2016-01-20 blake_r - Currently no where to place this information.
-    # Need to add to the model to store this information.
-    pass
-
-
-@transactional
-def get_rack_controllers_interfaces_as_dicts(system_id):
-    """Return all the interfaces on a given rack controller as a list of dicts.
-
-    :return: A list of dicts in the form {'name': interface.name,
-        'interface': interface.interface, 'ip': interface.ip}, one dict per
-        interface on the cluster.
-    """
-    interfaces = Interface.objects.filter(node__system_id=system_id)
-    # XXX 2016-01-20 blake_r - Currently not passing any IP address as it now
-    # should take a list of IP addresses and not just one IP address. To make
-    # it work for now nothing its filtered out.
-    return [
-        {
-            'name': interface.name,
-            'interface': interface.name,
-            'ip': '',
-        }
-        for interface in interfaces
-        ]
+def update_foreign_dhcp(system_id, interface_name, dhcp_ip=None):
+    """Update the external_dhcp field of the VLAN for the interface.
+
+    :param system_id: Rack controller system_id.
+    :param interface_name: The name of the interface.
+    :param dhcp_ip: The IP address of the responding DHCP server.
+    """
+    rack_controller = RackController.objects.get(system_id=system_id)
+    interface = rack_controller.interface_set.filter(
+        name=interface_name).select_related("vlan").first()
+    if interface is not None:
+        if dhcp_ip is not None:
+            sip = StaticIPAddress.objects.filter(ip=dhcp_ip).first()
+            if sip is not None:
+                # Check that its not an IP address of a rack controller
+                # providing that DHCP service.
+                rack_interfaces_serving_dhcp = sip.interface_set.filter(
+                    node__node_type__in=[
+                        NODE_TYPE.RACK_CONTROLLER,
+                        NODE_TYPE.REGION_AND_RACK_CONTROLLER],
+                    vlan__dhcp_on=True)
+                if rack_interfaces_serving_dhcp.exists():
+                    # Not external. It's a MAAS DHCP server.
+                    dhcp_ip = None
+        if interface.vlan.external_dhcp != dhcp_ip:
+            interface.vlan.external_dhcp = dhcp_ip
+            interface.vlan.save()
 
 
 @synchronous
 
=== modified file 'src/maasserver/rpc/regionservice.py'
--- src/maasserver/rpc/regionservice.py	2016-03-31 23:34:55 +0000
+++ src/maasserver/rpc/regionservice.py	2016-04-07 13:22:34 +0000
@@ -345,32 +345,19 @@
         return succeed({})
 
     @region.ReportForeignDHCPServer.responder
-    def report_foreign_dhcp_server(self, cluster_uuid, interface_name,
-                                   foreign_dhcp_ip):
+    def report_foreign_dhcp_server(
+            self, system_id, interface_name, dhcp_ip=None):
         """report_foreign_dhcp_server()
 
         Implementation of
-        :py:class:`~provisioningserver.rpc.region.SendEvent`.
+        :py:class:`~provisioningserver.rpc.region.ReportForeignDHCPServer`.
         """
         d = deferToDatabase(
-            rackcontrollers.update_foreign_dhcp_ip,
-            cluster_uuid, interface_name, foreign_dhcp_ip)
+            rackcontrollers.update_foreign_dhcp,
+            system_id, interface_name, dhcp_ip)
         d.addCallback(lambda _: {})
         return d
 
-    @region.GetClusterInterfaces.responder
-    def get_cluster_interfaces(self, cluster_uuid):
-        """get_cluster_interfaces()
-
-        Implementation of
-        :py:class:`~provisioningserver.rpc.region.GetClusterInterfaces`.
-        """
-        d = deferToDatabase(
-            rackcontrollers.get_rack_controllers_interfaces_as_dicts,
-            cluster_uuid)
-        d.addCallback(lambda interfaces: {'interfaces': interfaces})
-        return d
-
     @region.CreateNode.responder
     def create_node(self, architecture, power_type, power_parameters,
                     mac_addresses, domain=None, hostname=None):
 
=== modified file 'src/maasserver/rpc/tests/test_rackcontrollers.py'
--- src/maasserver/rpc/tests/test_rackcontrollers.py	2016-03-28 13:54:47 +0000
+++ src/maasserver/rpc/tests/test_rackcontrollers.py	2016-04-07 13:22:34 +0000
@@ -10,7 +10,11 @@
 from django.db import IntegrityError
 from fixtures import FakeLogger
 from maasserver import worker_user
-from maasserver.enum import NODE_TYPE
+from maasserver.enum import (
+    INTERFACE_TYPE,
+    IPADDRESS_TYPE,
+    NODE_TYPE,
+)
 from maasserver.models import (
     Node,
     NodeGroupToRackController,
@@ -20,6 +24,7 @@
     handle_upgrade,
     register_new_rackcontroller,
     register_rackcontroller,
+    update_foreign_dhcp,
     update_interfaces,
 )
 from maasserver.testing.factory import factory
@@ -248,6 +253,54 @@
             hostname, logger.output.strip())
 
 
+class TestUpdateForeignDHCP(MAASServerTestCase):
+
+    def test__doesnt_fail_if_interface_missing(self):
+        rack_controller = factory.make_RackController()
+        # No error should be raised.
+        update_foreign_dhcp(
+            rack_controller.system_id, factory.make_name("eth"), None)
+
+    def test__clears_external_dhcp_on_vlan(self):
+        rack_controller = factory.make_RackController(interface=False)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack_controller)
+        interface.vlan.external_dhcp = factory.make_ip_address()
+        interface.vlan.save()
+        update_foreign_dhcp(
+            rack_controller.system_id, interface.name, None)
+        self.assertIsNone(reload_object(interface.vlan).external_dhcp)
+
+    def test__sets_external_dhcp_when_not_managed_vlan(self):
+        rack_controller = factory.make_RackController(interface=False)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack_controller)
+        dhcp_ip = factory.make_ip_address()
+        update_foreign_dhcp(
+            rack_controller.system_id, interface.name, dhcp_ip)
+        self.assertEquals(
+            dhcp_ip, reload_object(interface.vlan).external_dhcp)
+
+    def test__clears_external_dhcp_when_managed_vlan(self):
+        rack_controller = factory.make_RackController(interface=False)
+        fabric = factory.make_Fabric()
+        vlan = fabric.get_default_vlan()
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack_controller, vlan=vlan)
+        subnet = factory.make_Subnet()
+        dhcp_ip = factory.pick_ip_in_Subnet(subnet)
+        vlan.dhcp_on = True
+        vlan.primary_rack = rack_controller
+        vlan.external_dhcp = dhcp_ip
+        vlan.save()
+        factory.make_StaticIPAddress(
+            alloc_type=IPADDRESS_TYPE.STICKY, ip=dhcp_ip,
+            subnet=subnet, interface=interface)
+        update_foreign_dhcp(
+            rack_controller.system_id, interface.name, dhcp_ip)
+        self.assertIsNone(reload_object(interface.vlan).external_dhcp)
+
+
 class TestUpdateInterfaces(MAASServerTestCase):
 
     def test__calls_update_interfaces_on_rack_controller(self):
 
=== modified file 'src/maasserver/rpc/tests/test_regionservice.py'
--- src/maasserver/rpc/tests/test_regionservice.py	2016-03-31 23:34:55 +0000
+++ src/maasserver/rpc/tests/test_regionservice.py	2016-04-07 13:22:34 +0000
@@ -121,7 +121,6 @@
     GetBootConfig,
     GetBootSources,
     GetBootSourcesV2,
-    GetClusterInterfaces,
     GetProxies,
     Identify,
     ListNodePowerParameters,
@@ -129,6 +128,7 @@
     RegisterEventType,
     RegisterRackController,
     ReportBootImages,
+    ReportForeignDHCPServer,
     RequestNodeInfoByMACAddress,
     SendEvent,
     SendEventMACAddress,
@@ -2590,101 +2590,47 @@
         # If the RPC service is down, _get_addresses() returns nothing.
         self.assertItemsEqual([], service._get_addresses())
 
-# NODE_GROUP_REMOVAL - blake_r - Fix.
-#class TestRegionProtocol_ReportForeignDHCPServer(
-#        MAASTransactionServerTestCase):
-#
-#    def test_create_node_is_registered(self):
-#        protocol = Region()
-#        responder = protocol.locateResponder(
-#            ReportForeignDHCPServer.commandName)
-#        self.assertIsNotNone(responder)
-#
-#    @transactional
-#    def create_cluster_interface(self):
-#        cluster = factory.make_NodeGroup()
-#        return factory.make_NodeGroupInterface(cluster)
-#
-#    @wait_for_reactor
-#    @inlineCallbacks
-#    def test_sets_foreign_dhcp_value(self):
-#        foreign_dhcp_ip = factory.make_ipv4_address()
-#        cluster_interface = yield deferToDatabase(
-#            self.create_cluster_interface)
-#        cluster = cluster_interface.nodegroup
-#
-#        response = yield call_responder(
-#            Region(), ReportForeignDHCPServer,
-#            {
-#                'cluster_uuid': cluster.uuid,
-#                'interface_name': cluster_interface.name,
-#                'foreign_dhcp_ip': foreign_dhcp_ip,
-#            })
-#
-#        self.assertEqual({}, response)
-#        cluster_interface = yield deferToDatabase(
-#            transactional_reload_object, cluster_interface)
-#
-#        self.assertEqual(
-#            foreign_dhcp_ip, cluster_interface.foreign_dhcp_ip)
-#
-#    @wait_for_reactor
-#    @inlineCallbacks
-#    def test_does_not_trigger_update_signal(self):
-#        configure_dhcp = self.patch_autospec(dhcp, "configure_dhcp")
-#
-#        foreign_dhcp_ip = factory.make_ipv4_address()
-#        cluster_interface = yield deferToDatabase(
-#            self.create_cluster_interface)
-#        cluster = cluster_interface.nodegroup
-#
-#        response = yield call_responder(
-#            Region(), ReportForeignDHCPServer,
-#            {
-#                'cluster_uuid': cluster.uuid,
-#                'interface_name': cluster_interface.name,
-#                'foreign_dhcp_ip': foreign_dhcp_ip,
-#            })
-#
-#        self.assertEqual({}, response)
-#        self.assertThat(configure_dhcp, MockNotCalled())
-
-
-class TestRegionProtocol_GetClusterInterfaces(MAASTransactionServerTestCase):
-
-    def test_create_node_is_registered(self):
+
+class TestRegionProtocol_ReportForeignDHCPServer(
+        MAASTransactionServerTestCase):
+
+    def test_is_registered(self):
         protocol = Region()
         responder = protocol.locateResponder(
-            GetClusterInterfaces.commandName)
+            ReportForeignDHCPServer.commandName)
         self.assertIsNotNone(responder)
 
     @transactional
-    def create_controller_and_interfaces(self):
-        controller = factory.make_RackController()
-        for _ in range(3):
-            factory.make_Interface(INTERFACE_TYPE.PHYSICAL, node=controller)
-        interfaces = [
+    def create_rack_interface(self):
+        rack_controller = factory.make_RackController(interface=False)
+        interface = factory.make_Interface(
+            INTERFACE_TYPE.PHYSICAL, node=rack_controller)
+        return rack_controller, interface
+
+    @transactional
+    def get_vlan_for_interface(self, interface):
+        return reload_object(interface.vlan)
+
+    @wait_for_reactor
+    @inlineCallbacks
+    def test_sets_external_dhcp_value(self):
+        dhcp_ip = factory.make_ipv4_address()
+        rack, interface = yield deferToDatabase(
+            self.create_rack_interface)
+
+        response = yield call_responder(
+            Region(), ReportForeignDHCPServer,
             {
-                'name': interface.name,
-                'interface': interface.name,
-                'ip': '',
-            }
-            for interface in controller.interface_set.all()]
-        return controller, interfaces
-
-    @wait_for_reactor
-    @inlineCallbacks
-    def test_returns_all_cluster_interfaces(self):
-        controller, expected_interfaces = yield deferToDatabase(
-            self.create_controller_and_interfaces)
-
-        response = yield call_responder(
-            Region(), GetClusterInterfaces,
-            {'cluster_uuid': controller.system_id})
-
-        self.assertIsNot(None, response)
-        self.assertItemsEqual(
-            expected_interfaces, response["interfaces"])
+                'system_id': rack.system_id,
+                'interface_name': interface.name,
+                'dhcp_ip': dhcp_ip,
+            })
+
+        self.assertEqual({}, response)
+        vlan = yield deferToDatabase(
+            self.get_vlan_for_interface, interface)
+        self.assertEqual(
+            dhcp_ip, vlan.external_dhcp)
 
 
 class TestRegionProtocol_CreateNode(MAASTransactionServerTestCase):
 
=== modified file 'src/provisioningserver/dhcp/detect.py'
--- src/provisioningserver/dhcp/detect.py	2016-03-28 13:54:47 +0000
+++ src/provisioningserver/dhcp/detect.py	2016-04-07 13:22:34 +0000
@@ -1,3 +1,4 @@
+
 # Copyright 2013-2016 Canonical Ltd.  This software is licensed under the
 # GNU Affero General Public License version 3 (see the file LICENSE).
 
@@ -10,21 +11,10 @@
 from contextlib import contextmanager
 import errno
 import fcntl
-import http.client
-import json
 from random import randint
 import socket
 import struct
-from urllib.error import (
-    HTTPError,
-    URLError,
-)
 
-from apiclient.maas_client import (
-    MAASClient,
-    MAASDispatcher,
-    MAASOAuth,
-)
 from provisioningserver.logger import get_maas_logger
 
 
@@ -204,64 +194,10 @@
     return receive_offers(transaction_id)
 
 
-def process_request(client_func, *args, **kwargs):
-    """Run a MAASClient query and check for common errors.
-
-    :return: None if there is an error, otherwise the decoded response body.
-    """
-    try:
-        response = client_func(*args, **kwargs)
-    except (HTTPError, URLError) as e:
-        maaslog.warning("Failed to contact region controller:\n%s", e)
-        return None
-    code = response.getcode()
-    if code != http.client.OK:
-        maaslog.error(
-            "Failed talking to region controller, it returned:\n%s\n%s",
-            code, response.read())
-        return None
-    try:
-        raw_data = response.read()
-        if len(raw_data) > 0:
-            data = json.loads(raw_data)
-        else:
-            return None
-    except ValueError as e:
-        maaslog.error(
-            "Failed to decode response from region controller:\n%s", e)
-        return None
-    return data
-
-
-def determine_cluster_interfaces(knowledge):
-    """Given server knowledge, determine network interfaces on this cluster.
-
-    :return: a list of tuples of (interface name, ip) for all interfaces.
-
-    :note: this uses an API call and not local probing because the
-        region controller has the definitive and final say in what does and
-        doesn't exist.
-    """
-    api_path = (
-        'api/2.0/nodegroups/%s/interfaces/' % knowledge['nodegroup_uuid'])
-    oauth = MAASOAuth(*knowledge['api_credentials'])
-    client = MAASClient(oauth, MAASDispatcher(), knowledge['maas_url'])
-    interfaces = process_request(client.get, api_path, 'list')
-    if interfaces is None:
-        return None
-
-    interface_names = sorted(
-        (interface['interface'], interface['ip'])
-        for interface in interfaces
-        if interface['interface'] != '')
-    return interface_names
-
-
-def probe_interface(interface, ip):
+def probe_interface(interface):
     """Probe the given interface for DHCP servers.
 
-    :param interface: interface as returned from determine_cluster_interfaces
-    :param ip: ip as returned from determine_cluster_interfaces
+    :param interface: interface name
     :return: A set of IP addresses of detected servers.
 
     :note: Any servers running on the IP address of the local host are
@@ -287,63 +223,4 @@
                 "your cluster interfaces configuration.", interface)
         else:
             raise
-    # Using servers.discard(ip) here breaks Mock in the tests, so
-    # we're creating a copy of the set instead.
-    results = servers.difference([ip])
-    return results
-
-
-def update_region_controller(knowledge, interface, server):
-    """Update the region controller with the status of the probe.
-
-    :param knowledge: dictionary of server info
-    :param interface: name of interface, e.g. eth0
-    :param server: IP address of detected DHCP server, or None
-    """
-    api_path = 'api/2.0/nodegroups/%s/interfaces/%s/' % (
-        knowledge['nodegroup_uuid'], interface)
-    oauth = MAASOAuth(*knowledge['api_credentials'])
-    client = MAASClient(oauth, MAASDispatcher(), knowledge['maas_url'])
-    if server is None:
-        server = ''
-    process_request(
-        client.post, api_path, 'report_foreign_dhcp', foreign_dhcp_ip=server)
-
-
-def periodic_probe_task(api_knowledge):
-    """Probe for DHCP servers and set NodeGroupInterface.foriegn_dhcp.
-
-    This should be run periodically so that the database has an up-to-date
-    view of any rogue DHCP servers on the network.
-
-    NOTE: This uses blocking I/O with sequential polling of interfaces, and
-    hence doesn't scale well.  It's a future improvement to make
-    to throw it in parallel threads or async I/O.
-
-    :param api_knowledge: A dict of the information needed to be able to
-        make requests to the region's REST API.
-    """
-    # Determine all the active interfaces on this cluster (nodegroup).
-    interfaces = determine_cluster_interfaces(api_knowledge)
-    if interfaces is None:
-        maaslog.info("No interfaces on cluster, not probing DHCP.")
-        return
-
-    # Iterate over interfaces and probe each one.
-    for interface, ip in interfaces:
-        try:
-            servers = probe_interface(interface, ip)
-        except socket.error:
-            maaslog.error(
-                "Failed to probe sockets; did you configure authbind as per "
-                "HACKING.txt?")
-            return
-        else:
-            if len(servers) > 0:
-                # Only send one, if it gets cleared out then the
-                # next detection pass will send a different one, if it
-                # still exists.
-                update_region_controller(
-                    api_knowledge, interface, servers.pop())
-            else:
-                update_region_controller(api_knowledge, interface, None)
+    return servers
 
=== removed file 'src/provisioningserver/dhcp/probe.py'
--- src/provisioningserver/dhcp/probe.py	2015-12-01 18:12:59 +0000
+++ src/provisioningserver/dhcp/probe.py	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-#!/usr/bin/env python2.7
-# Copyright 2013-2015 Canonical Ltd.  This software is licensed under the
-# GNU Affero General Public License version 3 (see the file LICENSE).
-
-"""Probe network on given network interface for a DHCP server.
-
-This needs to be run as root, in order to be allowed to broadcast on the
-BOOTP port.
-
-Exit code is zero ("success") if no servers were detected, or the number of
-DHCP servers that were found.
-"""
-
-import argparse
-from sys import exit
-
-from provisioningserver.dhcp.detect import probe_dhcp
-
-
-argument_parser = argparse.ArgumentParser(description=__doc__)
-
-
-def main():
-    argument_parser.add_argument(
-        'interface',
-        help="Probe network on this network interface.")
-
-    args = argument_parser.parse_args()
-
-    servers = probe_dhcp(args.interface)
-
-    num_servers = len(servers)
-    if num_servers == 0:
-        print("No DHCP servers detected.")
-        exit(0)
-    else:
-        print("DHCP servers detected: %s" % ', '.join(sorted(servers)))
-        exit(num_servers)
-
-if __name__ == "__main__":
-    main()
 
=== modified file 'src/provisioningserver/dhcp/tests/test_detect.py'
--- src/provisioningserver/dhcp/tests/test_detect.py	2016-03-28 13:54:47 +0000
+++ src/provisioningserver/dhcp/tests/test_detect.py	2016-04-07 13:22:34 +0000
@@ -7,39 +7,25 @@
 
 import errno
 import fcntl
-import http.client
 import socket
-import textwrap
-import urllib.error
-import urllib.parse
-import urllib.request
 
-from apiclient.maas_client import MAASClient
-from apiclient.testing.credentials import make_api_credentials
-from fixtures import FakeLogger
 from maastesting.factory import factory
-from maastesting.matchers import MockCalledOnceWith
 from maastesting.testcase import MAASTestCase
 import mock
-from mock import sentinel
 from provisioningserver.dhcp.detect import (
     BOOTP_CLIENT_PORT,
     BOOTP_SERVER_PORT,
-    determine_cluster_interfaces,
     DHCPDiscoverPacket,
     DHCPOfferPacket,
     get_interface_IP,
     get_interface_MAC,
     make_transaction_ID,
-    periodic_probe_task,
     probe_interface,
     receive_offers,
     request_dhcp,
     udp_socket,
-    update_region_controller,
 )
 import provisioningserver.dhcp.detect as detect_module
-from provisioningserver.testing.config import ClusterConfigurationFixture
 from provisioningserver.testing.testcase import PservTestCase
 
 
@@ -306,230 +292,35 @@
             receive_offers, factory.make_bytes(4))
 
 
-class MockResponse:
-    # This implements just enough to look lke a urllib2 response object.
-    def __init__(self, code=None, response=None):
-        if code is None:
-            code = http.client.OK
-        self.code = code
-        if response is None:
-            response = ""
-        self.response = response
-
-    def getcode(self):
-        return self.code
-
-    def read(self):
-        return self.response
-
-
 class TestPeriodicTask(PservTestCase):
 
-    def setUp(self):
-        # Initialise the knowledge cache.
-        super(TestPeriodicTask, self).setUp()
-        self.maaslog = self.useFixture(FakeLogger("maas.dhcp.detect"))
-        uuid = factory.make_UUID()
-        maas_url = 'http://%s.example.com/%s/' % (
-            factory.make_name('host'),
-            factory.make_string(),
-            )
-        api_credentials = make_api_credentials()
-        self.useFixture(ClusterConfigurationFixture(maas_url=maas_url))
-        self.knowledge = dict(
-            nodegroup_uuid=uuid,
-            api_credentials=api_credentials,
-            maas_url=maas_url)
-
-    def make_fake_interfaces_response(self, interfaces_pairs):
-        stanzas = []
-        for interfaces_pair in interfaces_pairs:
-            stanza = textwrap.dedent("""
-                {{
-                    "ip_range_high": null,
-                    "ip_range_low": null,
-                    "broadcast_ip": null,
-                    "ip": "{1}",
-                    "subnet_mask": "255.255.255.0",
-                    "management": 0,
-                    "interface": "{0}"
-                }}""").format(*interfaces_pair)
-            stanzas.append(stanza)
-        interfaces_json = "["
-        interfaces_json += ",".join(stanzas)
-        interfaces_json += "]"
-        return interfaces_json
-
-    def patch_fake_interfaces_list(self, interfaces_pairs):
-        # Set up the api client to return a fake set of interfaces.
-        # Determine_cluster_interfaces calls the API to discover what
-        # interfaces are available, so any test code that calls it
-        # should first call this helper to set up the required fake response.
-        interfaces_json = self.make_fake_interfaces_response(interfaces_pairs)
-        self.patch(MAASClient, 'get').return_value = MockResponse(
-            http.client.OK, interfaces_json)
-
-    def test_determine_cluster_interfaces_returns_interface_names(self):
-        eth0_addr = factory.make_ipv4_address()
-        wlan0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list(
-            [("eth0", eth0_addr), ("wlan0", wlan0_addr)])
-        self.assertEqual(
-            [("eth0", eth0_addr), ("wlan0", wlan0_addr)],
-            determine_cluster_interfaces(self.knowledge))
-
     def test_probe_interface_returns_empty_set_when_nothing_detected(self):
-        eth0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list([("eth0", eth0_addr)])
         self.patch(detect_module, 'probe_dhcp').return_value = set()
-        interfaces = determine_cluster_interfaces(self.knowledge)
-        results = probe_interface(*interfaces[0])
+        results = probe_interface("eth0")
         self.assertEqual(set(), results)
 
     def test_probe_interface_returns_empty_set_when_IP_missing(self):
         # If the interface being probed has no IP address, the
         # request_dhcr() method will raise IOError with errno 99. Make
         # sure this is caught and ignored.
-        eth0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list([("eth0", eth0_addr)])
         ioerror = IOError(
             errno.EADDRNOTAVAIL, "Cannot assign requested address")
         self.patch(fcntl, 'ioctl').side_effect = ioerror
-        interfaces = determine_cluster_interfaces(self.knowledge)
-        results = probe_interface(*interfaces[0])
+        results = probe_interface("eth0")
         self.assertEqual(set(), results)
 
     def test_probe_interface_returns_empty_set_when_device_missing(self):
         # If the interface being probed does not exist, the
         # request_dhcp() method will raise IOError with errno 19. Make
         # sure this is caught and ignored.
-        eth0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list([("eth0", eth0_addr)])
         ioerror = IOError(errno.ENODEV, "No such device")
         self.patch(fcntl, 'ioctl').side_effect = ioerror
-        interfaces = determine_cluster_interfaces(self.knowledge)
-        results = probe_interface(*interfaces[0])
+        results = probe_interface("eth0")
         self.assertEqual(set(), results)
 
     def test_probe_interface_returns_populated_set(self):
         # Test that the detected DHCP server is returned.
-        eth0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list([("eth0", eth0_addr)])
         self.patch(
             detect_module, 'probe_dhcp').return_value = {'10.2.2.2'}
-        interfaces = determine_cluster_interfaces(self.knowledge)
-        results = probe_interface(*interfaces[0])
+        results = probe_interface("eth0")
         self.assertEqual({'10.2.2.2'}, results)
-
-    def test_probe_interface_filters_interface_own_ip(self):
-        # Test that the interface shows the detected DHCP server except
-        # if it is the same IP as the interface's.
-        eth0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list([("eth0", eth0_addr)])
-        detected_dhcp = eth0_addr
-        self.patch(detect_module, 'probe_dhcp').return_value = {detected_dhcp}
-        interfaces = determine_cluster_interfaces(self.knowledge)
-        results = probe_interface(*interfaces[0])
-        self.assertEqual(set(), results)
-
-    def test_determine_cluster_interfaces_catchs_HTTPError_in_MAASClient(self):
-        self.patch(MAASClient, 'get').side_effect = urllib.error.HTTPError(
-            sentinel.url, sentinel.code, sentinel.msg, sentinel.hdrs, None)
-        determine_cluster_interfaces(self.knowledge)
-        self.assertIn(
-            "Failed to contact region controller:", self.maaslog.output)
-
-    def test_determine_cluster_interfaces_catches_URLError_in_MAASClient(self):
-        self.patch(MAASClient, 'get').side_effect = urllib.error.URLError(
-            sentinel.arg1)
-        determine_cluster_interfaces(self.knowledge)
-        self.assertIn(
-            "Failed to contact region controller:", self.maaslog.output)
-
-    def test_determine_cluster_interfaces_catches_non_OK_response(self):
-        self.patch(MAASClient, 'get').return_value = MockResponse(
-            http.client.NOT_FOUND, "error text")
-        determine_cluster_interfaces(self.knowledge)
-        self.assertIn(
-            "Failed talking to region controller, it returned:",
-            self.maaslog.output)
-
-    def test_update_region_controller_sets_detected_dhcp(self):
-        mocked_post = self.patch(MAASClient, 'post')
-        mocked_post.return_value = MockResponse()
-        detected_server = factory.make_ipv4_address()
-        update_region_controller(self.knowledge, "eth0", detected_server)
-        uuid = self.knowledge['nodegroup_uuid']
-        self.assertThat(mocked_post, MockCalledOnceWith(
-            'api/2.0/nodegroups/%s/interfaces/eth0/' % uuid,
-            'report_foreign_dhcp', foreign_dhcp_ip=detected_server))
-
-    def test_update_region_controller_clears_detected_dhcp(self):
-        mocked_post = self.patch(MAASClient, 'post')
-        mocked_post.return_value = MockResponse()
-        detected_server = None
-        update_region_controller(self.knowledge, "eth0", detected_server)
-        uuid = self.knowledge['nodegroup_uuid']
-        self.assertThat(mocked_post, MockCalledOnceWith(
-            'api/2.0/nodegroups/%s/interfaces/eth0/' % uuid,
-            'report_foreign_dhcp', foreign_dhcp_ip=''))
-
-    def test_update_region_controller_catches_HTTPError_in_MAASClient(self):
-        self.patch(MAASClient, 'post').side_effect = urllib.error.HTTPError(
-            sentinel.url, sentinel.code, sentinel.msg, sentinel.hdrs, None)
-        update_region_controller(self.knowledge, "eth0", None)
-        self.assertIn(
-            "Failed to contact region controller:", self.maaslog.output)
-
-    def test_update_region_controller_catches_URLError_in_MAASClient(self):
-        self.patch(MAASClient, 'post').side_effect = urllib.error.URLError(
-            sentinel.arg1)
-        update_region_controller(self.knowledge, "eth0", None)
-        self.assertIn(
-            "Failed to contact region controller:", self.maaslog.output)
-
-    def test_update_region_controller_catches_non_OK_response(self):
-        mock_response = MockResponse(http.client.NOT_FOUND, "error text")
-        self.patch(MAASClient, 'post').return_value = mock_response
-        update_region_controller(self.knowledge, "eth0", None)
-        self.assertIn(
-            "Failed talking to region controller, it returned:",
-            self.maaslog.output)
-
-    def test_periodic_probe_task_exits_if_no_interfaces(self):
-        mocked = self.patch(detect_module, 'probe_interface')
-        self.patch(
-            detect_module, 'determine_cluster_interfaces').return_value = None
-        periodic_probe_task(self.knowledge)
-        self.assertFalse(mocked.called)
-
-    def test_periodic_probe_task_updates_region_with_detected_server(self):
-        eth0_addr = factory.make_ipv4_address()
-        wlan0_addr = factory.make_ipv4_address()
-        detected_server = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list(
-            [("eth0", eth0_addr), ("wlan0", wlan0_addr)])
-        self.patch(
-            detect_module, 'probe_dhcp').return_value = {detected_server}
-        mocked_update = self.patch(detect_module, 'update_region_controller')
-        periodic_probe_task(self.knowledge)
-        calls = [
-            mock.call(self.knowledge, 'eth0', detected_server),
-            mock.call(self.knowledge, 'wlan0', detected_server),
-            ]
-        mocked_update.assert_has_calls(calls, any_order=True)
-
-    def test_periodic_probe_task_updates_region_with_no_detected_server(self):
-        eth0_addr = factory.make_ipv4_address()
-        wlan0_addr = factory.make_ipv4_address()
-        self.patch_fake_interfaces_list(
-            [("eth0", eth0_addr), ("wlan0", wlan0_addr)])
-        self.patch(
-            detect_module, 'probe_dhcp').return_value = set()
-        mocked_update = self.patch(detect_module, 'update_region_controller')
-        periodic_probe_task(self.knowledge)
-        calls = [
-            mock.call(self.knowledge, 'eth0', None),
-            mock.call(self.knowledge, 'wlan0', None),
-            ]
-        mocked_update.assert_has_calls(calls, any_order=True)
 
=== modified file 'src/provisioningserver/pserv_services/dhcp_probe_service.py'
--- src/provisioningserver/pserv_services/dhcp_probe_service.py	2016-03-28 13:54:47 +0000
+++ src/provisioningserver/pserv_services/dhcp_probe_service.py	2016-04-07 13:22:34 +0000
@@ -14,19 +14,14 @@
 from provisioningserver.dhcp.detect import probe_interface
 from provisioningserver.logger.log import get_maas_logger
 from provisioningserver.rpc.exceptions import NoConnectionsAvailable
-from provisioningserver.rpc.region import (
-    GetClusterInterfaces,
-    ReportForeignDHCPServer,
-)
+from provisioningserver.rpc.region import ReportForeignDHCPServer
+from provisioningserver.utils.network import get_all_interfaces_definition
 from provisioningserver.utils.twisted import (
     pause,
     retries,
 )
 from twisted.application.internet import TimerService
-from twisted.internet.defer import (
-    inlineCallbacks,
-    returnValue,
-)
+from twisted.internet.defer import inlineCallbacks
 from twisted.internet.threads import deferToThread
 from twisted.protocols.amp import UnhandledCommand
 
@@ -35,12 +30,11 @@
 
 
 class DHCPProbeService(TimerService, object):
-    """Service to probe for DHCP servers on this cluster's network.
+    """Service to probe for DHCP servers on the rack controller interface's.
 
     Built on top of Twisted's `TimerService`.
 
     :param reactor: An `IReactor` instance.
-    :param cluster_uuid: This cluster's UUID.
     """
 
     check_interval = timedelta(minutes=10).total_seconds()
@@ -52,48 +46,44 @@
         self.clock = reactor
         self.client_service = client_service
 
-    @inlineCallbacks
-    def _get_cluster_interfaces(self, client):
-        """Return the interfaces for this cluster."""
-        try:
-            response = yield client(
-                GetClusterInterfaces, cluster_uuid=client.localIdent)
-        except UnhandledCommand:
-            # The region hasn't been upgraded to support this method
-            # yet, so give up. Returning an empty dict means that this
-            # run will end, since there are no interfaces to check.
-            maaslog.error(
-                "Unable to query region for interfaces: Region does not "
-                "support the GetClusterInterfaces RPC method.")
-            returnValue({})
-        else:
-            returnValue(response['interfaces'])
+    def _get_interfaces(self):
+        """Return the interfaces for this rack controller."""
+        d = deferToThread(get_all_interfaces_definition)
+        d.addCallback(lambda interfaces: [
+            name
+            for name, info in interfaces.items()
+            if info["enabled"]
+        ])
+        return d
 
-    @inlineCallbacks
-    def _inform_region_of_foreign_dhcp(self, client, name,
-                                       foreign_dhcp_ip):
-        """Tell the region that there's a rogue DHCP server.
+    def _inform_region_of_dhcp(self, client, name, dhcp_ip):
+        """Tell the region about the DHCP server.
 
         :param client: The RPC client to use.
         :param name: The name of the network interface where the rogue
             DHCP server was found.
-        :param foreign_dhcp_ip: The IP address of the rogue server.
+        :param dhcp_ip: The IP address of the DHCP server.
         """
-        try:
-            yield client(
-                ReportForeignDHCPServer, cluster_uuid=client.localIdent,
-                interface_name=name, foreign_dhcp_ip=foreign_dhcp_ip)
-        except UnhandledCommand:
+
+        def eb_unhandled(failure):
+            failure.trap(UnhandledCommand)
             # Not a lot we can do here... The region doesn't support
             # this method yet.
             maaslog.error(
-                "Unable to inform region of rogue DHCP server: the region "
+                "Unable to inform region of DHCP server: the region "
                 "does not yet support the ReportForeignDHCPServer RPC "
                 "method.")
 
+        d = client(
+            ReportForeignDHCPServer, system_id=client.localIdent,
+            interface_name=name, dhcp_ip=dhcp_ip)
+        d.addErrback(eb_unhandled)
+        return d
+
     @inlineCallbacks
     def probe_dhcp(self):
-        """Find all the interfaces on this cluster and probe for DHCP servers.
+        """Find all the interfaces on this rack controller and probe for
+        DHCP servers.
         """
         client = None
         for elapsed, remaining, wait in retries(15, 5, self.clock):
@@ -107,12 +97,11 @@
                 "Can't initiate DHCP probe, no RPC connection to region.")
             return
 
-        cluster_interfaces = yield self._get_cluster_interfaces(client)
         # Iterate over interfaces and probe each one.
-        for interface in cluster_interfaces:
+        interfaces = yield self._get_interfaces()
+        for interface in interfaces:
             try:
-                servers = yield deferToThread(
-                    probe_interface, interface['interface'], interface['ip'])
+                servers = yield deferToThread(probe_interface, interface)
             except socket.error:
                 maaslog.error(
                     "Failed to probe sockets; did you configure authbind as "
@@ -123,11 +112,11 @@
                     # Only send one, if it gets cleared out then the
                     # next detection pass will send a different one, if it
                     # still exists.
-                    yield self._inform_region_of_foreign_dhcp(
-                        client, interface['name'], servers.pop())
+                    yield self._inform_region_of_dhcp(
+                        client, interface, servers.pop())
                 else:
-                    yield self._inform_region_of_foreign_dhcp(
-                        client, interface['name'], None)
+                    yield self._inform_region_of_dhcp(
+                        client, interface, None)
 
     @inlineCallbacks
     def try_probe_dhcp(self):
@@ -136,7 +125,7 @@
             yield self.probe_dhcp()
         except Exception as error:
             maaslog.error(
-                "Unable to probe for rogue DHCP servers: %s",
+                "Unable to probe for DHCP servers: %s",
                 str(error))
         else:
             maaslog.debug("Finished periodic DHCP probe.")
 
=== modified file 'src/provisioningserver/pserv_services/tests/test_dhcp_probe_service.py'
--- src/provisioningserver/pserv_services/tests/test_dhcp_probe_service.py	2016-03-28 13:54:47 +0000
+++ src/provisioningserver/pserv_services/tests/test_dhcp_probe_service.py	2016-04-07 13:22:34 +0000
@@ -11,10 +11,12 @@
     get_mock_calls,
     HasLength,
     MockCalledOnceWith,
+    MockCallsMatch,
     MockNotCalled,
 )
 from maastesting.testcase import MAASTwistedRunTest
 from mock import (
+    call,
     Mock,
     sentinel,
 )
@@ -39,19 +41,9 @@
     def patch_rpc_methods(self):
         fixture = self.useFixture(MockLiveClusterToRegionRPCFixture())
         protocol, connecting = fixture.makeEventLoop(
-            region.GetClusterInterfaces, region.ReportForeignDHCPServer)
+            region.ReportForeignDHCPServer)
         return protocol, connecting
 
-    def make_cluster_interface_values(self, ip=None):
-        """Return a dict describing a cluster interface."""
-        if ip is None:
-            ip = factory.make_ipv4_address()
-        return {
-            'name': factory.make_name('interface'),
-            'interface': factory.make_name('eth'),
-            'ip': ip,
-            }
-
     def test_is_called_every_interval(self):
         clock = Clock()
         service = DHCPProbeService(
@@ -82,67 +74,47 @@
 
     def test_probe_is_initiated_in_new_thread(self):
         clock = Clock()
-        interface = self.make_cluster_interface_values()
-        rpc_service = Mock()
-        rpc_client = rpc_service.getClient.return_value
-        rpc_client.side_effect = [
-            defer.succeed(dict(interfaces=[interface])),
-        ]
+        interface_name = factory.make_name("eth")
+        interfaces = {
+            interface_name: {
+                "enabled": True,
+            }
+        }
 
-        # We could patch out 'periodic_probe_task' instead here but this
-        # is better because:
-        # 1. The former requires spinning the reactor again before being
-        #    able to test the result.
-        # 2. This way there's no thread to clean up after the test.
         deferToThread = self.patch(dhcp_probe_service, 'deferToThread')
-        deferToThread.return_value = defer.succeed(None)
-        service = DHCPProbeService(
-            rpc_service, clock)
+        deferToThread.side_effect = [
+            defer.succeed(interfaces),
+            defer.succeed(None),
+        ]
+        service = DHCPProbeService(Mock(), clock)
         service.startService()
         self.assertThat(
-            deferToThread, MockCalledOnceWith(
-                dhcp_probe_service.probe_interface,
-                interface['interface'], interface['ip']))
-
-    @defer.inlineCallbacks
-    def test_exits_gracefully_if_cant_get_interfaces(self):
-        clock = Clock()
-        maaslog = self.patch(dhcp_probe_service, 'maaslog')
-
-        protocol, connecting = self.patch_rpc_methods()
-        self.addCleanup((yield connecting))
-
-        del protocol._commandDispatch[
-            region.GetClusterInterfaces.commandName]
-        rpc_service = Mock()
-        rpc_service.getClient.return_value = getRegionClient()
-        service = DHCPProbeService(
-            rpc_service, clock)
-        yield service.startService()
-        yield service.stopService()
-
-        self.assertThat(
-            maaslog.error, MockCalledOnceWith(
-                "Unable to query region for interfaces: Region does not "
-                "support the GetClusterInterfaces RPC method."))
+            deferToThread, MockCallsMatch(
+                call(dhcp_probe_service.get_all_interfaces_definition),
+                call(dhcp_probe_service.probe_interface, interface_name)))
 
     @defer.inlineCallbacks
     def test_exits_gracefully_if_cant_report_foreign_dhcp_server(self):
         clock = Clock()
+        interface_name = factory.make_name("eth")
+        interfaces = {
+            interface_name: {
+                "enabled": True,
+            }
+        }
+
         maaslog = self.patch(dhcp_probe_service, 'maaslog')
         deferToThread = self.patch(
             dhcp_probe_service, 'deferToThread')
-        deferToThread.return_value = defer.succeed(['192.168.0.100'])
+        deferToThread.side_effect = [
+            defer.succeed(interfaces),
+            defer.succeed(['192.168.0.100']),
+        ]
         protocol, connecting = self.patch_rpc_methods()
         self.addCleanup((yield connecting))
 
         del protocol._commandDispatch[
             region.ReportForeignDHCPServer.commandName]
-        protocol.GetClusterInterfaces.return_value = {
-            'interfaces': [
-                self.make_cluster_interface_values(ip='192.168.0.1'),
-                ],
-            }
 
         rpc_service = Mock()
         rpc_service.getClient.return_value = getRegionClient()
@@ -153,13 +125,23 @@
 
         self.assertThat(
             maaslog.error, MockCalledOnceWith(
-                "Unable to inform region of rogue DHCP server: the region "
+                "Unable to inform region of DHCP server: the region "
                 "does not yet support the ReportForeignDHCPServer RPC "
                 "method."))
 
     def test_logs_errors(self):
         clock = Clock()
+        interface_name = factory.make_name("eth")
+        interfaces = {
+            interface_name: {
+                "enabled": True,
+            }
+        }
+
         maaslog = self.patch(dhcp_probe_service, 'maaslog')
+        mock_interfaces = self.patch(
+            dhcp_probe_service, 'get_all_interfaces_definition')
+        mock_interfaces.return_value = interfaces
         service = DHCPProbeService(
             sentinel.service, clock)
         error_message = factory.make_string()
@@ -168,25 +150,29 @@
         service.startService()
         self.assertThat(
             maaslog.error, MockCalledOnceWith(
-                "Unable to probe for rogue DHCP servers: %s",
+                "Unable to probe for DHCP servers: %s",
                 error_message))
 
     @defer.inlineCallbacks
     def test_reports_foreign_dhcp_servers_to_region(self):
         clock = Clock()
+        interface_name = factory.make_name("eth")
+        interfaces = {
+            interface_name: {
+                "enabled": True,
+            }
+        }
+
         protocol, connecting = self.patch_rpc_methods()
         self.addCleanup((yield connecting))
 
         deferToThread = self.patch(
             dhcp_probe_service, 'deferToThread')
         foreign_dhcp_ip = factory.make_ipv4_address()
-        deferToThread.return_value = defer.succeed(
-            [foreign_dhcp_ip])
-
-        interface = self.make_cluster_interface_values()
-        protocol.GetClusterInterfaces.return_value = {
-            'interfaces': [interface],
-            }
+        deferToThread.side_effect = [
+            defer.succeed(interfaces),
+            defer.succeed([foreign_dhcp_ip]),
+        ]
 
         client = getRegionClient()
         rpc_service = Mock()
@@ -201,24 +187,29 @@
             protocol.ReportForeignDHCPServer,
             MockCalledOnceWith(
                 protocol,
-                cluster_uuid=client.localIdent,
-                interface_name=interface['name'],
-                foreign_dhcp_ip=foreign_dhcp_ip))
+                system_id=client.localIdent,
+                interface_name=interface_name,
+                dhcp_ip=foreign_dhcp_ip))
 
     @defer.inlineCallbacks
     def test_reports_lack_of_foreign_dhcp_servers_to_region(self):
         clock = Clock()
+        interface_name = factory.make_name("eth")
+        interfaces = {
+            interface_name: {
+                "enabled": True,
+            }
+        }
+
         protocol, connecting = self.patch_rpc_methods()
         self.addCleanup((yield connecting))
 
         deferToThread = self.patch(
             dhcp_probe_service, 'deferToThread')
-        deferToThread.return_value = defer.succeed([])
-
-        interface = self.make_cluster_interface_values()
-        protocol.GetClusterInterfaces.return_value = {
-            'interfaces': [interface],
-            }
+        deferToThread.side_effect = [
+            defer.succeed(interfaces),
+            defer.succeed([]),
+        ]
 
         client = getRegionClient()
         rpc_service = Mock()
@@ -232,6 +223,6 @@
             protocol.ReportForeignDHCPServer,
             MockCalledOnceWith(
                 protocol,
-                cluster_uuid=client.localIdent,
-                interface_name=interface['name'],
-                foreign_dhcp_ip=None))
+                system_id=client.localIdent,
+                interface_name=interface_name,
+                dhcp_ip=None))
 
=== modified file 'src/provisioningserver/rpc/region.py'
--- src/provisioningserver/rpc/region.py	2016-03-28 13:54:47 +0000
+++ src/provisioningserver/rpc/region.py	2016-04-07 13:22:34 +0000
@@ -14,7 +14,6 @@
     "GetBootConfig",
     "GetBootSources",
     "GetBootSourcesV2",
-    "GetClusterInterfaces",
     "GetProxies",
     "Identify",
     "ListNodePowerParameters",
@@ -337,38 +336,20 @@
 
 
 class ReportForeignDHCPServer(amp.Command):
-    """Report a foreign DHCP server on the cluster's network.
+    """Report a foreign DHCP server on a rack controller's interface.
 
-    :since: 1.7
+    :since: 2.0
     """
 
     arguments = [
-        (b"cluster_uuid", amp.Unicode()),
+        (b"system_id", amp.Unicode()),
         (b"interface_name", amp.Unicode()),
-        (b"foreign_dhcp_ip", amp.Unicode(optional=True)),
+        (b"dhcp_ip", amp.Unicode(optional=True)),
     ]
     response = []
     errors = []
 
 
-class GetClusterInterfaces(amp.Command):
-    """Fetch the known interfaces for a cluster from the region.
-
-    :since: 1.7
-    """
-
-    arguments = [
-        (b"cluster_uuid", amp.Unicode()),
-    ]
-    response = [
-        (b"interfaces", AmpList(
-            [(b"name", amp.Unicode()),
-             (b"interface", amp.Unicode()),
-             (b"ip", amp.Unicode())]))
-    ]
-    errors = []
-
-
 class CreateNode(amp.Command):
     """Create a node on a given cluster.