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

[Lee Trager]

Have the rack request a refresh on connect instead of the region determining if one is needed.

This modifies the rack registration process so the region no longer determines if a refresh is needed. The network monitoring service will now request a refresh the first time it can connect to a region. As the network monitoring service runs every 30 seconds the refresh typically doesn't occur until the rack has been running for 30 seconds. This is because as soon as the rack starts the network monitoring service tries and fails to obtain an RPC client for the region as the connection hasn't been made yet. lp:~ltrager/maas/region_refresh modifies the region to refresh itself on start which will ensure region and rack controllers are refreshed as soon as the region service comes up.

As discussed this also removes the refresh API and websockets. Users who want to run a refresh on a controller will have to restart the maas-regiond or maas-rackd service.

[Blake Rouse (blake-rouse)]

Looks good. Just one comment.

review: Approve

[Lee Trager (ltrager)]

Accidentally had this to merge into a previous branch and not trunk.

review: Approve

=== modified file 'src/maasserver/api/rackcontrollers.py'
--- src/maasserver/api/rackcontrollers.py	2016-05-16 08:36:33 +0000
+++ src/maasserver/api/rackcontrollers.py	2016-06-09 23:56:03 +0000
@@ -124,21 +124,6 @@
 
     @admin_method
     @operation(idempotent=False)
-    def refresh(self, request, system_id):
-        """Refresh the hardware information for a specific rack controller.
-
-        Returns 404 if the rack-controller is not found.
-        Returns 403 if the user does not have permission to refresh the rack.
-        """
-        rack = self.model.objects.get_node_or_404(
-            system_id=system_id, user=request.user, perm=NODE_PERMISSION.EDIT)
-        rack.refresh()
-        return HttpResponse(
-            "Refresh of %s has begun" % rack.hostname,
-            content_type=("text/plain; charset=%s" % settings.DEFAULT_CHARSET))
-
-    @admin_method
-    @operation(idempotent=False)
     def import_boot_images(self, request, system_id):
         """Import the boot images on this rack controller.
 

=== modified file 'src/maasserver/api/tests/test_rackcontroller.py'
--- src/maasserver/api/tests/test_rackcontroller.py	2016-05-24 22:05:45 +0000
+++ src/maasserver/api/tests/test_rackcontroller.py	2016-06-09 23:56:03 +0000
@@ -7,7 +7,6 @@
 
 from django.core.urlresolvers import reverse
 from maasserver.api import rackcontrollers
-from maasserver.models import node as node_module
 from maasserver.testing.api import (
     APITestCase,
     explain_unexpected_response,
@@ -49,22 +48,6 @@
         response = self.client.put(self.get_rack_uri(rack), {})
         self.assertEqual(http.client.FORBIDDEN, response.status_code)
 
-    def test_POST_refresh_checks_permission(self):
-        self.patch(node_module.RackController, 'refresh')
-        rack = factory.make_RackController(owner=factory.make_User())
-        response = self.client.post(self.get_rack_uri(rack), {'op': 'refresh'})
-        self.assertEqual(http.client.FORBIDDEN, response.status_code)
-
-    def test_POST_refresh_returns_null(self):
-        self.patch(node_module.RackController, 'refresh')
-        self.become_admin()
-        rack = factory.make_RackController(owner=factory.make_User())
-        response = self.client.post(self.get_rack_uri(rack), {'op': 'refresh'})
-        self.assertEqual(http.client.OK, response.status_code)
-        self.assertEqual(
-            ('Refresh of %s has begun' % rack.hostname).encode('utf-8'),
-            response.content)
-
     def test_POST_import_boot_images_import_to_rack_controllers(self):
         from maasserver.clusterrpc import boot_images
         self.patch(boot_images, "RackControllersImporter")

=== modified file 'src/maasserver/models/node.py'
--- src/maasserver/models/node.py	2016-06-08 08:37:14 +0000
+++ src/maasserver/models/node.py	2016-06-09 23:56:03 +0000
@@ -3606,7 +3606,11 @@
     def _get_token_for_controller(self):
         # Avoid circular imports.
         from metadataserver.models import NodeKey
-        return NodeKey.objects.get_token_for_node(self)
+        token = NodeKey.objects.get_token_for_node(self)
+        # Pull consumer into memory so it can be accessed outside a
+        # database thread
+        token.consumer
+        return token
 
     @transactional
     def _get_current_node_result_ids(self):

=== modified file 'src/maasserver/node_action.py'
--- src/maasserver/node_action.py	2016-05-26 06:47:45 +0000
+++ src/maasserver/node_action.py	2016-06-09 23:56:03 +0000
@@ -482,25 +482,6 @@
             raise NodeActionError(exception)
 
 
-class Refresh(NodeAction):
-    """Refresh a rack or region and rack controller."""
-    name = "refresh"
-    display = "Refresh"
-    display_sentence = "refreshed"
-    permission = NODE_PERMISSION.ADMIN
-    for_type = {
-        NODE_TYPE.RACK_CONTROLLER,
-        NODE_TYPE.REGION_AND_RACK_CONTROLLER
-    }
-
-    def execute(self):
-        """See `NodeAction.execute`."""
-        try:
-            self.node.refresh()
-        except RPC_EXCEPTIONS + (ExternalProcessError,) as exception:
-            raise NodeActionError(exception)
-
-
 ACTION_CLASSES = (
     Commission,
     Acquire,
@@ -514,7 +495,6 @@
     SetZone,
     Delete,
     ImportImages,
-    Refresh,
 )
 
 ACTIONS_DICT = OrderedDict((action.name, action) for action in ACTION_CLASSES)

=== modified file 'src/maasserver/rpc/rackcontrollers.py'
--- src/maasserver/rpc/rackcontrollers.py	2016-05-31 19:15:43 +0000
+++ src/maasserver/rpc/rackcontrollers.py	2016-06-09 23:56:03 +0000
@@ -80,7 +80,7 @@
     registered and successfully connected we will refresh all commissioning
     data.
 
-    :return: A ``(rack-controller, refresh-hint)`` tuple.
+    :return: A ``rack-controller``.
     """
     if interfaces is None:
         interfaces = {}
@@ -91,13 +91,18 @@
         maaslog.info("Created new rack controller %s.", node.hostname)
     elif node.is_rack_controller:
         maaslog.info("Registering existing rack controller %s.", node.hostname)
+    elif node.is_region_controller:
+        maaslog.info(
+            "Converting %s into a region and rack controller.", node.hostname)
+        node.node_type = NODE_TYPE.REGION_AND_RACK_CONTROLLER
+        node.save()
     else:
-        maaslog.info(
-            "Found existing node %s as candidate for rack controller.",
-            node.hostname)
-
-    # This may be a no-op, but it does provide us with a refresh hint.
-    rackcontroller, needs_refresh = upgrade(node)
+        maaslog.info("Converting %s into a rack controller.", node.hostname)
+        node.node_type = NODE_TYPE.RACK_CONTROLLER
+        node.save()
+
+    rackcontroller = typecast_node(node, RackController)
+
     # Update `rackcontroller.url` from the given URL, but only when the
     # hostname is not 'localhost' (i.e. the default value used when the master
     # cluster connects).
@@ -112,8 +117,7 @@
     rackcontroller.save(update_fields=update_fields)
     # Update networking information every time we see a rack.
     rackcontroller.update_interfaces(interfaces)
-    # Hint to callers whether or not this rack needs to be refreshed.
-    return rackcontroller, needs_refresh
+    return rackcontroller
 
 
 @typed
@@ -136,40 +140,6 @@
     return Node.objects.filter(query).first()
 
 
-def upgrade(node):
-    """Upgrade `node` to a rack controller if it isn't already.
-
-    Return a hint as to whether a refresh is necessary.
-
-    :return: A ``(rack-controller, refresh-hint)`` tuple.
-    """
-    # Refresh whenever an existing node is converted for use as a rack
-    # controller. This is needed for two reasons. First, when the region starts
-    # it creates a node for itself but only gathers networking information.
-    # Second, information about the node may have changed since its last use.
-    needs_refresh = True
-
-    if node.is_rack_controller:
-        # We don't want to refresh existing rack controllers as each time a
-        # rack controller connects to a region it creates four connections.
-        # This means for every region we connect to we would refresh
-        # 4 * regions every time the rack controller restarts. If the cpu_count
-        # and memory is non-zero our information at this point should be
-        # current and the user can always manually refresh.
-        needs_refresh = (node.cpu_count == 0 or node.memory == 0)
-    elif node.is_region_controller:
-        maaslog.info(
-            "Converting %s into a region and rack controller.", node.hostname)
-        node.node_type = NODE_TYPE.REGION_AND_RACK_CONTROLLER
-        node.save()
-    else:
-        maaslog.info("Converting %s into a rack controller.", node.hostname)
-        node.node_type = NODE_TYPE.RACK_CONTROLLER
-        node.save()
-
-    return typecast_node(node, RackController), needs_refresh
-
-
 @transactional
 def update_foreign_dhcp(system_id, interface_name, dhcp_ip=None):
     """Update the external_dhcp field of the VLAN for the interface.

=== modified file 'src/maasserver/rpc/regionservice.py'
--- src/maasserver/rpc/regionservice.py	2016-05-27 13:14:01 +0000
+++ src/maasserver/rpc/regionservice.py	2016-06-09 23:56:03 +0000
@@ -445,6 +445,18 @@
         return deferToDatabase(
             update_services, system_id, services)
 
+    @region.RequestRackRefresh.responder
+    def request_rack_refresh(self, system_id):
+        """Request a refresh of the rack
+
+        Implementation of
+        :py:class:`~provisioningserver.rpc.region.RequestRackRefresh`.
+        """
+        d = deferToDatabase(RackController.objects.get, system_id=system_id)
+        d.addCallback(lambda rack: rack.refresh())
+        d.addCallback(lambda _: {})
+        return d
+
 
 @transactional
 def registerConnection(region_id, rack_controller, host):
@@ -534,7 +546,7 @@
 
         try:
             # Register, which includes updating interfaces.
-            rack_controller, needs_refresh = yield deferToDatabase(
+            rack_controller = yield deferToDatabase(
                 rackcontrollers.register, system_id=system_id,
                 hostname=hostname, interfaces=interfaces, url=url)
 
@@ -568,13 +580,6 @@
             # the information about the rack controller if needed.
             log.msg(
                 "Rack controller '%s' has been registered." % self.ident)
-            if self.hostIsRemote and needs_refresh:
-                # Needs to be refresh. Perform this operation in a thread but
-                # we ignore when it is done.
-                log.msg(
-                    "Rack controller '%s' needs to be refreshed; "
-                    "performing the refresh operation." % self.ident)
-                deferToDatabase(rack_controller.refresh)
 
             # Done registering the rack controller and connection.
             return {'system_id': self.ident}

=== modified file 'src/maasserver/rpc/testing/fixtures.py'
--- src/maasserver/rpc/testing/fixtures.py	2016-05-27 13:14:01 +0000
+++ src/maasserver/rpc/testing/fixtures.py	2016-06-09 23:56:03 +0000
@@ -321,7 +321,7 @@
         # Mock the registration into the database, as the rack controller is
         # already created. We reset this once registration is complete so as
         # to not interfere with other tests.
-        registered = rack_controller, False  # Hint that no refresh needed.
+        registered = rack_controller
         patcher = MonkeyPatcher()
         patcher.add_patch(
             rackcontrollers, "register",

=== modified file 'src/maasserver/rpc/tests/test_rackcontrollers.py'
--- src/maasserver/rpc/tests/test_rackcontrollers.py	2016-05-31 19:17:13 +0000
+++ src/maasserver/rpc/tests/test_rackcontrollers.py	2016-06-09 23:56:03 +0000
@@ -108,23 +108,23 @@
 
     def test_sets_owner_to_worker_when_none(self):
         node = factory.make_Node()
-        rack_registered, needs_refresh = register(system_id=node.system_id)
+        rack_registered = register(system_id=node.system_id)
         self.assertEqual(worker_user.get_worker_user(), rack_registered.owner)
 
     def test_leaves_owner_when_owned(self):
         user = factory.make_User()
         node = factory.make_Machine(owner=user)
-        rack_registered, needs_refresh = register(system_id=node.system_id)
+        rack_registered = register(system_id=node.system_id)
         self.assertEqual(user, rack_registered.owner)
 
     def test_finds_existing_node_by_system_id(self):
         node = factory.make_Node()
-        rack_registered, needs_refresh = register(system_id=node.system_id)
+        rack_registered = register(system_id=node.system_id)
         self.assertEqual(node.system_id, rack_registered.system_id)
 
     def test_finds_existing_node_by_hostname(self):
         node = factory.make_Node()
-        rack_registered, needs_refresh = register(hostname=node.hostname)
+        rack_registered = register(hostname=node.hostname)
         self.assertEqual(node.system_id, rack_registered.system_id)
 
     def test_finds_existing_node_by_mac(self):
@@ -140,39 +140,9 @@
                 "enabled": True,
             }
         }
-        rack_registered, needs_refresh = register(interfaces=interfaces)
+        rack_registered = register(interfaces=interfaces)
         self.assertEqual(node.system_id, rack_registered.system_id)
 
-    def test_finds_existing_controller_needs_refresh_with_bad_info(self):
-        node_type = random.choice([
-            NODE_TYPE.RACK_CONTROLLER,
-            NODE_TYPE.REGION_AND_RACK_CONTROLLER,
-        ])
-        node = factory.make_Node(node_type=node_type)
-        rack_registered, needs_refresh = register(system_id=node.system_id)
-        self.assertTrue(needs_refresh)
-
-    def test_finds_existing_controller_doesnt_need_refresh_good_info(self):
-        node_type = random.choice([
-            NODE_TYPE.RACK_CONTROLLER,
-            NODE_TYPE.REGION_AND_RACK_CONTROLLER,
-        ])
-        node = factory.make_Node(
-            node_type=node_type, cpu_count=random.randint(1, 32),
-            memory=random.randint(1024, 8096))
-        rack_registered, needs_refresh = register(system_id=node.system_id)
-        self.assertFalse(needs_refresh)
-
-    def test_converts_existing_node_sets_needs_refresh_to_true(self):
-        node_type = random.choice([
-            NODE_TYPE.MACHINE,
-            NODE_TYPE.DEVICE,
-            NODE_TYPE.REGION_CONTROLLER,
-        ])
-        node = factory.make_Node(node_type=node_type)
-        rack_registered, needs_refresh = register(system_id=node.system_id)
-        self.assertTrue(needs_refresh)
-
     def test_find_existing_keeps_type(self):
         node_type = random.choice(
             (NODE_TYPE.RACK_CONTROLLER, NODE_TYPE.REGION_AND_RACK_CONTROLLER))
@@ -190,7 +160,7 @@
 
     def test_converts_region_controller(self):
         node = factory.make_Node(node_type=NODE_TYPE.REGION_CONTROLLER)
-        rack_registered, needs_refresh = register(system_id=node.system_id)
+        rack_registered = register(system_id=node.system_id)
         self.assertEqual(
             rack_registered.node_type, NODE_TYPE.REGION_AND_RACK_CONTROLLER)
 
@@ -199,14 +169,12 @@
         node = factory.make_Node(node_type=NODE_TYPE.REGION_CONTROLLER)
         register(system_id=node.system_id)
         self.assertEqual(
-            "Found existing node %s as candidate for rack controller.\n"
-            "Converting %s into a region and rack controller.\n"
-            % (node.hostname, node.hostname),
-            logger.output)
+            "Converting %s into a region and rack controller.\n" %
+            node.hostname, logger.output)
 
     def test_converts_existing_node(self):
         node = factory.make_Node(node_type=NODE_TYPE.MACHINE)
-        rack_registered, needs_refresh = register(system_id=node.system_id)
+        rack_registered = register(system_id=node.system_id)
         self.assertEqual(rack_registered.node_type, NODE_TYPE.RACK_CONTROLLER)
 
     def test_logs_converting_existing_node(self):
@@ -214,9 +182,7 @@
         node = factory.make_Node(node_type=NODE_TYPE.MACHINE)
         register(system_id=node.system_id)
         self.assertEqual(
-            "Found existing node %s as candidate for rack controller.\n"
-            "Converting %s into a rack controller.\n"
-            % (node.hostname, node.hostname),
+            "Converting %s into a rack controller.\n" % node.hostname,
             logger.output)
 
     def test_creates_new_rackcontroller(self):
@@ -234,19 +200,6 @@
         register(interfaces=interfaces)
         self.assertEqual(node_count + 1, len(Node.objects.all()))
 
-    def test_creates_new_rackcontroller_sets_needs_refresh_to_true(self):
-        interfaces = {
-            factory.make_name("eth0"): {
-                "type": "physical",
-                "mac_address": factory.make_mac_address(),
-                "parents": [],
-                "links": [],
-                "enabled": True,
-            }
-        }
-        rack_registered, needs_refresh = register(interfaces=interfaces)
-        self.assertTrue(needs_refresh)
-
     def test_logs_creating_new_rackcontroller(self):
         logger = self.useFixture(FakeLogger("maas"))
         hostname = factory.make_name("hostname")
@@ -266,7 +219,7 @@
                 "enabled": True,
             }
         }
-        rack_registered, needs_refresh = register(interfaces=interfaces)
+        rack_registered = register(interfaces=interfaces)
         self.assertThat(
             rack_registered.interface_set.all(),
             MatchesSetwise(*(
@@ -293,7 +246,7 @@
                 "enabled": True,
             }
         }
-        rack_registered, needs_refresh = register(
+        rack_registered = register(
             rack_controller.system_id, interfaces=interfaces)
         self.assertThat(
             rack_registered.interface_set.all(),

=== modified file 'src/maasserver/rpc/tests/test_regionservice.py'
--- src/maasserver/rpc/tests/test_regionservice.py	2016-05-27 13:14:01 +0000
+++ src/maasserver/rpc/tests/test_regionservice.py	2016-06-09 23:56:03 +0000
@@ -523,7 +523,7 @@
         protocol.transport.getHost.return_value = host
         mock_deferToDatabase = self.patch(regionservice, "deferToDatabase")
         mock_deferToDatabase.side_effect = [
-            succeed((rack_controller, False)),
+            succeed(rack_controller),
             succeed(None),
         ]
         yield call_responder(

=== modified file 'src/maasserver/rpc/tests/test_regionservice_calls.py'
--- src/maasserver/rpc/tests/test_regionservice_calls.py	2016-05-25 21:03:50 +0000
+++ src/maasserver/rpc/tests/test_regionservice_calls.py	2016-06-09 23:56:03 +0000
@@ -59,6 +59,7 @@
 )
 from maasserver.utils.threads import deferToDatabase
 from maastesting.matchers import (
+    MockCalledOnce,
     MockCalledOnceWith,
     MockCalledWith,
 )
@@ -84,6 +85,7 @@
     ReportBootImages,
     ReportForeignDHCPServer,
     RequestNodeInfoByMACAddress,
+    RequestRackRefresh,
     SendEvent,
     SendEventMACAddress,
     UpdateInterfaces,
@@ -1233,3 +1235,25 @@
         params = {'mac_address': factory.make_mac_address()}
         d = call_responder(Region(), RequestNodeInfoByMACAddress, params)
         return assert_fails_with(d, NoSuchNode)
+
+
+class TestRegionProtocol_RequestRefresh(MAASTransactionServerTestCase):
+
+    def test_request_refresh_is_registered(self):
+        protocol = Region()
+        responder = protocol.locateResponder(
+            RequestRackRefresh.commandName)
+        self.assertIsNotNone(responder)
+
+    @wait_for_reactor
+    @inlineCallbacks
+    def test_calls_refresh(self):
+        rack = yield deferToDatabase(factory.make_RackController)
+        self.patch(regionservice, 'deferToDatabase').return_value = succeed(
+            rack)
+        mock_refresh = self.patch(rack, 'refresh')
+        response = yield call_responder(
+            Region(), RequestRackRefresh, {'system_id': rack.system_id})
+        self.assertIsNotNone(response)
+
+        self.assertThat(mock_refresh, MockCalledOnce())

=== modified file 'src/maasserver/tests/test_node_action.py'
--- src/maasserver/tests/test_node_action.py	2016-05-26 06:47:45 +0000
+++ src/maasserver/tests/test_node_action.py	2016-06-09 23:56:03 +0000
@@ -5,7 +5,6 @@
 
 __all__ = []
 
-import random
 from unittest.mock import ANY
 
 from django.db import transaction
@@ -28,10 +27,7 @@
     signals,
     StaticIPAddress,
 )
-from maasserver.models.node import (
-    RackController,
-    typecast_to_node_type,
-)
+from maasserver.models.node import typecast_to_node_type
 from maasserver.models.signals.testing import SignalsDisabled
 from maasserver.node_action import (
     Abort,
@@ -46,7 +42,6 @@
     NodeAction,
     PowerOff,
     PowerOn,
-    Refresh,
     Release,
     RPC_EXCEPTIONS,
     SetZone,
@@ -854,33 +849,6 @@
         self.assertFalse(ImportImages(node, user).is_actionable())
 
 
-class TestRefresh(MAASServerTestCase):
-
-    def test_refresh(self):
-        user = factory.make_admin()
-        rack = factory.make_RackController()
-        mock_refresh = self.patch(rack, 'refresh')
-
-        with post_commit_hooks:
-            Refresh(rack, user).execute()
-
-        self.assertThat(mock_refresh, MockCalledOnce())
-
-    def test_requires_admin_permission(self):
-        user = factory.make_User()
-        rack = factory.make_RackController()
-        self.assertFalse(Refresh(rack, user).is_permitted())
-
-    def test_requires_rack(self):
-        user = factory.make_User()
-        node = factory.make_Node(
-            node_type=factory.pick_choice(
-                NODE_TYPE_CHOICES, but_not=[
-                    NODE_TYPE.RACK_CONTROLLER,
-                    NODE_TYPE.REGION_AND_RACK_CONTROLLER]))
-        self.assertFalse(Refresh(node, user).is_actionable())
-
-
 class TestActionsErrorHandling(MAASServerTestCase):
     """Tests for error handling in actions.
 
@@ -904,8 +872,6 @@
         exception = self.make_exception()
         self.patch(node, '_start').side_effect = exception
         self.patch(node, '_stop').side_effect = exception
-        if isinstance(node, RackController):
-            self.patch(node, 'refresh').side_effect = exception
 
     def make_action(
             self, action_class, node_status, power_state=None,
@@ -961,15 +927,3 @@
         self.assertEqual(
             get_error_message_for_exception(action.node._stop.side_effect),
             str(exception))
-
-    def test_Refresh_handles_rpc_errors(self):
-        action = self.make_action(
-            Refresh, NODE_STATUS.ALLOCATED, power_state=POWER_STATE.ON,
-            node_type=random.choice([
-                NODE_TYPE.RACK_CONTROLLER,
-                NODE_TYPE.REGION_AND_RACK_CONTROLLER]))
-        self.patch_rpc_methods(action.node)
-        exception = self.assertRaises(NodeActionError, action.execute)
-        self.assertEqual(
-            get_error_message_for_exception(action.node._stop.side_effect),
-            str(exception))

=== modified file 'src/maasserver/websockets/handlers/tests/test_general.py'
--- src/maasserver/websockets/handlers/tests/test_general.py	2016-05-26 06:47:45 +0000
+++ src/maasserver/websockets/handlers/tests/test_general.py	2016-06-09 23:56:03 +0000
@@ -144,7 +144,7 @@
     def test_rack_controller_actions_for_admin(self):
         handler = GeneralHandler(factory.make_admin(), {})
         self.assertItemsEqual(
-            ['delete', 'import-images', 'off', 'on', 'refresh', 'set-zone'],
+            ['delete', 'import-images', 'off', 'on', 'set-zone'],
             [action['name'] for action in handler.rack_controller_actions({})])
 
     def test_rack_controller_actions_for_non_admin(self):
@@ -154,7 +154,7 @@
     def test_region_and_rack_controller_actions_for_admin(self):
         handler = GeneralHandler(factory.make_admin(), {})
         self.assertItemsEqual(
-            ['set-zone', 'refresh', 'delete', 'import-images'],
+            ['set-zone', 'delete', 'import-images'],
             [action['name']
              for action in handler.region_and_rack_controller_actions({})])
 

=== modified file 'src/provisioningserver/pserv_services/networks_monitoring_service.py'
--- src/provisioningserver/pserv_services/networks_monitoring_service.py	2016-06-03 17:31:53 +0000
+++ src/provisioningserver/pserv_services/networks_monitoring_service.py	2016-06-09 23:56:03 +0000
@@ -8,7 +8,10 @@
 ]
 
 from provisioningserver.logger.log import get_maas_logger
-from provisioningserver.rpc.region import UpdateInterfaces
+from provisioningserver.rpc.region import (
+    RequestRackRefresh,
+    UpdateInterfaces,
+)
 from provisioningserver.utils.services import NetworksMonitoringService
 
 
@@ -25,6 +28,10 @@
     def recordInterfaces(self, interfaces):
         """Record the interfaces information."""
         client = self.clientService.getClient()
-        return client(
-            UpdateInterfaces, system_id=client.localIdent,
-            interfaces=interfaces)
+        # On first run perform a refresh
+        if self._recorded is None:
+            return client(RequestRackRefresh, system_id=client.localIdent)
+        else:
+            return client(
+                UpdateInterfaces, system_id=client.localIdent,
+                interfaces=interfaces)

=== modified file 'src/provisioningserver/pserv_services/tests/test_networks_monitoring_service.py'
--- src/provisioningserver/pserv_services/tests/test_networks_monitoring_service.py	2016-06-04 08:51:04 +0000
+++ src/provisioningserver/pserv_services/tests/test_networks_monitoring_service.py	2016-06-09 23:56:03 +0000
@@ -29,6 +29,22 @@
     run_tests_with = MAASTwistedRunTest.make_factory(timeout=5)
 
     @inlineCallbacks
+    def test_runs_refresh_first_time(self):
+        fixture = self.useFixture(MockLiveClusterToRegionRPCFixture())
+        protocol, connecting = fixture.makeEventLoop(region.RequestRackRefresh)
+        self.addCleanup((yield connecting))
+
+        rpc_service = services.getServiceNamed('rpc')
+        service = RackNetworksMonitoringService(rpc_service, Clock())
+
+        yield service.startService()
+        yield service.stopService()
+
+        self.assertThat(
+            protocol.RequestRackRefresh, MockCalledOnceWith(
+                protocol, system_id=rpc_service.getClient().localIdent))
+
+    @inlineCallbacks
     def test_reports_interfaces_to_region(self):
         fixture = self.useFixture(MockLiveClusterToRegionRPCFixture())
         protocol, connecting = fixture.makeEventLoop(region.UpdateInterfaces)
@@ -47,6 +63,10 @@
         rpc_service = services.getServiceNamed('rpc')
         service = RackNetworksMonitoringService(rpc_service, Clock())
         service.getInterfaces = lambda: succeed(interfaces)
+        # Put something in the cache. This tells recordInterfaces that refresh
+        # has already run but the interfaces have changed thus they need to be
+        # updated.
+        service._interfacesRecorded({})
 
         yield service.startService()
         yield service.stopService()

=== modified file 'src/provisioningserver/rpc/region.py'
--- src/provisioningserver/rpc/region.py	2016-05-11 00:25:14 +0000
+++ src/provisioningserver/rpc/region.py	2016-06-09 23:56:03 +0000
@@ -480,3 +480,16 @@
     errors = {
         NoSuchCluster: b"NoSuchCluster",
     }
+
+
+class RequestRackRefresh(amp.Command):
+    """Request a refresh of the rack from the region.
+
+    :since: 2.0
+    """
+
+    arguments = [
+        (b"system_id", amp.Unicode()),
+    ]
+    response = []
+    errors = []