Merge lp:~mpontillo/maas/rdns-service--bug-1633822--part2 into lp:~maas-committers/maas/trunk

[Mike Pontillo]

Store reverse-DNS lookups in the database whenever neighbours are updated.

 * Add trigger boilerplate so we can register with the listener for
   changes to the neighbour table.
 * Add ReverseDNSService to listen for neighbour changes.
 * Add utilities to reverse-resolve IP addresses, and sort the results.

[Lee Trager (ltrager)]

LGTM!

review: Approve

[MAAS Lander (maas-lander)]

Attempt to merge into lp:maas failed due to conflicts:

text conflict in src/provisioningserver/utils/tests/test_network.py

=== modified file 'src/maasserver/eventloop.py'
--- src/maasserver/eventloop.py	2016-09-23 03:32:14 +0000
+++ src/maasserver/eventloop.py	2016-10-24 19:31:16 +0000
@@ -143,6 +143,13 @@
     return ActiveDiscoveryService(reactor, postgresListener)
 
 
+def make_ReverseDNSService(postgresListener):
+    from maasserver.regiondservices.reverse_dns import (
+        ReverseDNSService
+    )
+    return ReverseDNSService(postgresListener)
+
+
 def make_NetworkTimeProtocolService():
     from maasserver.regiondservices import ntp
     return ntp.RegionNetworkTimeProtocolService(reactor)
@@ -269,6 +276,11 @@
             "factory": make_ActiveDiscoveryService,
             "requires": ["postgres-listener"],
         },
+        "reverse-dns": {
+            "only_on_master": True,
+            "factory": make_ReverseDNSService,
+            "requires": ["postgres-listener"],
+        },
         "rack-controller": {
             "only_on_master": False,
             "factory": make_RackControllerService,

=== added file 'src/maasserver/regiondservices/reverse_dns.py'
--- src/maasserver/regiondservices/reverse_dns.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/regiondservices/reverse_dns.py	2016-10-24 19:31:16 +0000
@@ -0,0 +1,99 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Reverse DNS service."""
+
+__all__ = [
+    "ReverseDNSService"
+]
+
+from typing import List
+
+from maasserver.listener import PostgresListenerService
+from maasserver.models import (
+    RDNS,
+    RegionController,
+)
+from maasserver.utils.threads import deferToDatabase
+from provisioningserver.utils.network import reverseResolve
+from twisted.application.service import Service
+from twisted.internet.defer import inlineCallbacks
+from twisted.python import log
+
+
+class ReverseDNSService(Service):
+    """Service to resolve and cache reverse DNS names for neighbour entries."""
+
+    def __init__(self, postgresListener: PostgresListenerService=None):
+        super().__init__()
+        self.listener = postgresListener
+        # We will cache a reference to the region model object so we don't
+        # need to look it up every time a DNS entry changes.
+        self.region = None
+
+    @inlineCallbacks
+    def startService(self):
+        super().startService()
+        self.region = yield deferToDatabase(
+            RegionController.objects.get_running_controller)
+        if self.listener is not None:
+            self.listener.register('neighbour', self.consumeNeighbourEvent)
+
+    def stopService(self):
+        if self.listener is not None:
+            self.listener.unregister('neighbour', self.consumeNeighbourEvent)
+        return super().stopService()
+
+    def set_rdns_entry(self, ip: str, results: List[str]):
+        """Set the reverse-DNS entry for the specified IP address.
+
+        Must run in a thread where database access is permitted.
+
+        :param ip: the IP address to update.
+        :param results: a non-empty list of hostnames for the specified IP,
+            in "preferred" order.
+        """
+        RDNS.objects.set_current_entry(ip, results, self.region)
+
+    def delete_rdns_entry(self, ip: str):
+        """Delete the reverse-DNS entry for the specified IP address.
+
+        Must run in a thread where database access is permitted.
+
+        :param ip: the IP address to delete.
+        """
+        RDNS.objects.delete_current_entry(ip, self.region)
+
+    @inlineCallbacks
+    def consumeNeighbourEvent(self, action: str=None, cidr: str=None):
+        """Given an event from the postgresListener, resolve RDNS for an IP.
+
+        This method is called when an observed neighbour is changed.
+
+        :param action: one of {'create', 'update', 'delete'}
+        :param cidr: the 'ip' field in the neighbour table, after PostgreSQL
+            casts it to a string. It will end up looking like "x.x.x.x/32"
+            or "yyyy:yyyy::yyyy/128".
+        """
+        ip = cidr.split('/')[0]  # Strip off the "/<prefixlen>".
+        if action in ('create', 'update'):
+            # XXX mpontillo 2016-10-19: We might consider throttling this on
+            # a per-IP-address basis, both because multiple racks can observe
+            # the same IP address, and because an IP address might repeatedly
+            # go back-and-forth between two MACs in the case of a duplicate IP
+            # address.
+            results = yield reverseResolve(ip)
+            if results is not None:
+                if len(results) > 0:
+                    yield deferToDatabase(self.set_rdns_entry, ip, results)
+                else:
+                    yield deferToDatabase(self.delete_rdns_entry, ip)
+            else:
+                # A return of 'None' indicates a timeout or other possibly-
+                # temporary failure, so take no action.
+                pass
+        elif action == 'delete':
+            yield deferToDatabase(self.delete_rdns_entry, ip)
+        else:
+            log.msg("Unsupported event from listener: action=%r, cidr=%r" % (
+                action, cidr), system="reverse-dns")

=== added file 'src/maasserver/regiondservices/tests/test_reverse_dns.py'
--- src/maasserver/regiondservices/tests/test_reverse_dns.py	1970-01-01 00:00:00 +0000
+++ src/maasserver/regiondservices/tests/test_reverse_dns.py	2016-10-24 19:31:16 +0000
@@ -0,0 +1,111 @@
+# Copyright 2016 Canonical Ltd.  This software is licensed under the
+# GNU Affero General Public License version 3 (see the file LICENSE).
+
+"""Tests for reverse-DNS service."""
+
+__all__ = []
+
+from unittest.mock import Mock
+
+from crochet import wait_for
+from maasserver.models import RDNS
+from maasserver.regiondservices import reverse_dns as reverse_dns_module
+from maasserver.regiondservices.reverse_dns import ReverseDNSService
+from maasserver.testing.factory import factory
+from maasserver.testing.testcase import MAASTransactionServerTestCase
+from maasserver.utils.threads import deferToDatabase
+from maastesting.matchers import MockCalledOnceWith
+from provisioningserver.utils.tests.test_network import (
+    TestReverseResolveMixIn,
+)
+from testtools.matchers import (
+    Equals,
+    Is,
+)
+from twisted.internet.defer import inlineCallbacks
+
+
+class TestReverseDNSService(
+        TestReverseResolveMixIn, MAASTransactionServerTestCase):
+    """Tests for `RegionNetworksMonitoringService`."""
+
+    def setUp(self):
+        super().setUp()
+        self.region = factory.make_RegionRackController()
+        # This is so get_running_controller() works properly.
+        RegionController = self.patch(reverse_dns_module, "RegionController")
+        RegionController.objects = Mock()
+        RegionController.objects.get_running_controller = Mock()
+        RegionController.objects.get_running_controller.return_value = (
+            self.region)
+
+    @wait_for(30)
+    @inlineCallbacks
+    def test__caches_region_model_object(self):
+        hostname = factory.make_hostname()
+        self.set_fake_twisted_dns_reply([hostname])
+        service = ReverseDNSService()
+        yield service.startService()
+        self.assertThat(service.region, Equals(self.region))
+        service.stopService()
+
+    @wait_for(30)
+    @inlineCallbacks
+    def test__adds_rdns_entry(self):
+        hostname = factory.make_hostname()
+        self.set_fake_twisted_dns_reply([hostname])
+        service = ReverseDNSService()
+        yield service.startService()
+        ip = factory.make_ip_address(ipv6=False)
+        yield service.consumeNeighbourEvent("create", "%s/32" % ip)
+        service.stopService()
+        result = yield deferToDatabase(RDNS.objects.first)
+        self.assertThat(result.ip, Equals(ip))
+        self.assertThat(result.hostname, Equals(hostname))
+
+    @wait_for(30)
+    @inlineCallbacks
+    def test__updates_rdns_entry(self):
+        hostname = factory.make_hostname()
+        hostname2 = factory.make_hostname()
+        self.set_fake_twisted_dns_reply([hostname])
+        service = ReverseDNSService()
+        yield service.startService()
+        ip = factory.make_ip_address(ipv6=False)
+        yield service.consumeNeighbourEvent("create", "%s/32" % ip)
+        self.set_fake_twisted_dns_reply([hostname2])
+        yield service.consumeNeighbourEvent("update", "%s/32" % ip)
+        service.stopService()
+        result = yield deferToDatabase(RDNS.objects.first)
+        self.assertThat(result.ip, Equals(ip))
+        self.assertThat(result.hostname, Equals(hostname2))
+
+    @wait_for(30)
+    @inlineCallbacks
+    def test__deletes_rdns_entry(self):
+        hostname = factory.make_hostname()
+        self.set_fake_twisted_dns_reply([hostname])
+        service = ReverseDNSService()
+        yield service.startService()
+        ip = factory.make_ip_address(ipv6=False)
+        yield service.consumeNeighbourEvent("create", "%s/32" % ip)
+        yield service.consumeNeighbourEvent("delete", "%s/32" % ip)
+        service.stopService()
+        result = yield deferToDatabase(RDNS.objects.first)
+        self.assertThat(result, Is(None))
+
+    @wait_for(30)
+    @inlineCallbacks
+    def test__registers_and_unregisters_listener(self):
+        listener = Mock()
+        listener.register = Mock()
+        listener.unregister = Mock()
+        service = ReverseDNSService(postgresListener=listener)
+        yield service.startService()
+        self.assertThat(listener.register, MockCalledOnceWith(
+            'neighbour', service.consumeNeighbourEvent
+        ))
+        service.stopService()
+        self.assertThat(listener.unregister, MockCalledOnceWith(
+            'neighbour', service.consumeNeighbourEvent
+        ))

=== modified file 'src/maasserver/tests/test_plugin.py'
--- src/maasserver/tests/test_plugin.py	2016-10-19 21:08:54 +0000
+++ src/maasserver/tests/test_plugin.py	2016-10-24 19:31:16 +0000
@@ -103,6 +103,7 @@
             "postgres-listener",
             "rack-controller",
             "region-controller",
+            "reverse-dns",
             "rpc",
             "rpc-advertise",
             "service-monitor",

=== modified file 'src/maasserver/triggers/tests/test_websocket.py'
--- src/maasserver/triggers/tests/test_websocket.py	2016-10-12 15:26:17 +0000
+++ src/maasserver/triggers/tests/test_websocket.py	2016-10-24 19:31:16 +0000
@@ -78,6 +78,9 @@
             "vlan_vlan_create_notify",
             "vlan_vlan_update_notify",
             "vlan_vlan_delete_notify",
+            "neighbour_neighbour_create_notify",
+            "neighbour_neighbour_update_notify",
+            "neighbour_neighbour_delete_notify",
             "iprange_iprange_create_notify",
             "iprange_iprange_update_notify",
             "iprange_iprange_delete_notify",

=== modified file 'src/maasserver/triggers/websocket.py'
--- src/maasserver/triggers/websocket.py	2016-10-12 15:26:17 +0000
+++ src/maasserver/triggers/websocket.py	2016-10-24 19:31:16 +0000
@@ -1033,6 +1033,23 @@
     register_trigger(
         "maasserver_iprange", "iprange_delete_notify", "delete")
 
+    # Neighbour table
+    register_procedure(
+        render_notification_procedure(
+            'neighbour_create_notify', 'neighbour_create', 'NEW.ip'))
+    register_procedure(
+        render_notification_procedure(
+            'neighbour_update_notify', 'neighbour_update', 'NEW.ip'))
+    register_procedure(
+        render_notification_procedure(
+            'neighbour_delete_notify', 'neighbour_delete', 'OLD.ip'))
+    register_trigger(
+        "maasserver_neighbour", "neighbour_create_notify", "insert")
+    register_trigger(
+        "maasserver_neighbour", "neighbour_update_notify", "update")
+    register_trigger(
+        "maasserver_neighbour", "neighbour_delete_notify", "delete")
+
     # StaticRoute table
     register_procedure(
         render_notification_procedure(

=== modified file 'src/provisioningserver/utils/network.py'
--- src/provisioningserver/utils/network.py	2016-10-21 18:59:57 +0000
+++ src/provisioningserver/utils/network.py	2016-10-24 19:31:16 +0000
@@ -11,12 +11,13 @@
     'get_all_interface_addresses',
     'is_loopback_address',
     'make_network',
+    'reverseResolve',
     'resolve_host_to_addrinfo',
     'resolve_hostname',
     'resolves_to_loopback_address',
     'intersect_iprange',
     'ip_range_within_network',
-    ]
+]
 
 import codecs
 from collections import namedtuple
@@ -56,6 +57,15 @@
 from provisioningserver.utils.ps import running_in_container
 from provisioningserver.utils.shell import call_and_check
 from provisioningserver.utils.twisted import synchronous
+from twisted.internet.defer import inlineCallbacks
+from twisted.internet.interfaces import IResolver
+from twisted.names.client import createResolver
+from twisted.names.error import (
+    AuthoritativeDomainError,
+    DNSQueryTimeoutError,
+    DomainError,
+    ResolverError,
+)
 
 # Address families in /etc/network/interfaces that MAAS chooses to parse. All
 # other families are ignored.
@@ -73,6 +83,9 @@
 ]
 
 
+REVERSE_RESOLVE_RETRIES = (1, 2, 4, 8, 16)
+
+
 # Type hints for `outer_range` parameter (get_unused_ranges()).
 OuterRange = TypeVar('OuterRange', IPRange, IPNetwork, bytes, str)
 
@@ -1225,3 +1238,89 @@
         return any(
             is_loopback_address(sockaddr[0])
             for _, _, _, _, sockaddr in addrinfo)
+
+
+def getDefaultIResolver() -> IResolver:
+    """Get a new `IResolver` based on default resolver settings on this host.
+
+    That is, the Twisted default settings for the resolver will be used: first
+    /etc/hosts will be checked, then the DNS servers /etc/resolv.conf will be
+    queried.
+
+    If a resolver fails to be set up this way, a resolver will be created
+    pointing to 127.0.0.1:53 (perhaps a dnsmasq or similar setup is in use),
+    per the twisted behavior when using their globally-cached resolver.
+    """
+    # Rather than calling getResolver() here (which creates a global, cached
+    # resolver), we create a new resolver each time. This is in case the
+    # contents of /etc/hosts or /etc/resolv.conf have changed. (Doing this
+    # should not be slow, but we do negate the benefits of the in-memory cache
+    # in Twisted's global resolver.)
+    try:
+        return createResolver()
+    except ValueError:
+        # Mimic the behavior of the Twisted `getResolver()` function in case
+        # the resolver cannot be created. (presumably, because there was an
+        # error parsing /etc/resolv.conf or similar).
+        return createResolver(servers=[('127.0.0.1', 53)])
+
+
+def preferred_hostnames_sort_key(fqdn: str):
+    """Return the sort key for the given FQDN, to sort in "preferred" order."""
+    fqdn = fqdn.rstrip('.')
+    subdomains = fqdn.split('.')
+    # Sort by TLDs first.
+    subdomains.reverse()
+    key = (
+        # First, prefer "more qualified" hostnames. (Since the sort will be
+        # ascending, we need to negate this.) For example, if a reverse lookup
+        # returns `[www.ubuntu.com, ubuntu.com]`, we prefer `www.ubuntu.com`,
+        # even though 'w' sorts after 'u'.
+        -len(subdomains),
+        # Second, sort by domain components.
+        subdomains
+    )
+    return key
+
+
+@inlineCallbacks
+def reverseResolve(
+        ip: MaybeIPAddress, resolver: IResolver=None) -> Optional[List[str]]:
+    """Using the specified IResolver, reverse-resolves the specifed `ip`.
+
+    :return: a sorted list of resolved hostnames (which the specified IP
+        address reverse-resolves to). If the DNS lookup appeared to succeed,
+        but no hostnames were found, returns an empty list. If the DNS lookup
+        timed out or an error occurred, returns None.
+    """
+    if resolver is None:
+        resolver = getDefaultIResolver()
+    ip = IPAddress(ip)
+    try:
+        data = yield resolver.lookupPointer(
+            ip.reverse_dns, timeout=REVERSE_RESOLVE_RETRIES)
+        # I love the concise way in which I can ask the Twisted data structure
+        # what the list of hostnames is. This is great.
+        results = sorted(
+            (rr.payload.name.name.decode("idna") for rr in data[0]),
+            key=preferred_hostnames_sort_key
+        )
+    except AuthoritativeDomainError:
+        # "Failed to reverse-resolve '%s': authoritative failure." % ip
+        # This means the name didn't resolve, so return an empty list.
+        return []
+    except DomainError:
+        # "Failed to reverse-resolve '%s': no records found." % ip
+        # This means the name didn't resolve, so return an empty list.
+        return []
+    except DNSQueryTimeoutError:
+        # "Failed to reverse-resolve '%s': timed out." % ip
+        # Don't return an empty list since this implies a temporary failure.
+        pass
+    except ResolverError:
+        # "Failed to reverse-resolve '%s': rejected by local resolver." % ip
+        # Don't return an empty list since this could be temporary (unclear).
+        pass
+    else:
+        return results
+    return None

=== modified file 'src/provisioningserver/utils/tests/test_network.py'
--- src/provisioningserver/utils/tests/test_network.py	2016-10-21 18:28:17 +0000
+++ src/provisioningserver/utils/tests/test_network.py	2016-10-24 19:31:16 +0000
@@ -13,14 +13,22 @@
     gaierror,
     IPPROTO_TCP,
 )
+from typing import List
 from unittest import mock
-from unittest.mock import Mock
+from unittest.mock import (
+    call,
+    Mock,
+    sentinel,
+)
 
 from maastesting.factory import factory
 from maastesting.matchers import (
+    MockCalledOnce,
     MockCalledOnceWith,
+    MockCallsMatch,
     MockNotCalled,
 )
+from maastesting.runtest import MAASTwistedRunTest
 from maastesting.testcase import MAASTestCase
 from netaddr import (
     IPAddress,
@@ -51,6 +59,7 @@
     get_eui_organization,
     get_interface_children,
     get_mac_organization,
+    getDefaultIResolver,
     has_ipv4_address,
     hex_str_to_bytes,
     inet_ntop,
@@ -64,11 +73,14 @@
     make_iprange,
     make_network,
     parse_integer,
+    preferred_hostnames_sort_key,
     resolve_host_to_addrinfo,
     resolve_hostname,
     resolves_to_loopback_address,
+    reverseResolve,
 )
 from provisioningserver.utils.shell import call_and_check
+from testtools import ExpectedException
 from testtools.matchers import (
     Contains,
     ContainsAll,
@@ -79,6 +91,13 @@
     MatchesSetwise,
     Not,
 )
+from twisted.internet.defer import inlineCallbacks
+from twisted.names.error import (
+    AuthoritativeDomainError,
+    DNSQueryTimeoutError,
+    DomainError,
+    ResolverError,
+)
 
 
 installed_curtin_version = call_and_check([
@@ -1776,6 +1795,7 @@
 
 
 class TestIsLoopbackAddress(MAASTestCase):
+
     def test_handles_ipv4_loopback(self):
         network = IPNetwork('127.0.0.0/8')
         address = factory.pick_ip_in_network(network)
@@ -1825,6 +1845,7 @@
 
 
 class TestResolvesToLoopbackAddress(MAASTestCase):
+
     def test_resolves_hostnames(self):
         gai = self.patch(socket, 'getaddrinfo')
         gai.return_value = ((
@@ -1844,3 +1865,237 @@
         self.assertEqual(resolves_to_loopback_address(name), False)
         self.assertThat(
             gai, MockCalledOnceWith(name, None, proto=IPPROTO_TCP))
+
+
+class TestGetDefaultIResolver(MAASTestCase):
+
+    def setUp(self):
+        super().setUp()
+        self.createResolver = self.patch(
+            network_module, "createResolver")
+
+    def test__uses_twisted_createResolver_by_default(self):
+        self.createResolver.return_value = sentinel.default_resolver
+        resolver = getDefaultIResolver()
+        self.assertThat(self.createResolver, MockCalledOnceWith())
+        self.assertThat(resolver, Is(sentinel.default_resolver))
+
+    def test__falls_back_to_localhost_based_resolver(self):
+        self.createResolver.side_effect = [
+            ValueError, sentinel.localhost_resolver]
+        resolver = getDefaultIResolver()
+        self.assertThat(resolver, Is(sentinel.localhost_resolver))
+        self.assertThat(self.createResolver, MockCallsMatch(
+            call(), call(servers=[('127.0.0.1', 53)])
+        ))
+
+
+class TestPreferredHostnamesSortKey(MAASTestCase):
+    """Tests for `preferred_hostnames_sort_key()`."""
+
+    def test__sorts_flat_names(self):
+        names = ('c', 'b', 'a', 'z')
+        self.assertThat(
+            sorted(names, key=preferred_hostnames_sort_key),
+            Equals(['a', 'b', 'c', 'z'])
+        )
+
+    def test__sorts_more_qualified_names_first(self):
+        names = (
+            'diediedie.archive.ubuntu.com',
+            'wpps.org.za',
+            'ubuntu.com',
+            'ubuntu.sets.a.great.example.com',
+        )
+        self.assertThat(
+            sorted(names, key=preferred_hostnames_sort_key),
+            Equals([
+                'ubuntu.sets.a.great.example.com',
+                'diediedie.archive.ubuntu.com',
+                'wpps.org.za',
+                'ubuntu.com',
+            ])
+        )
+
+    def test__sorts_by_domains_then_hostnames_within_each_domain(self):
+        names = (
+            'www.ubuntu.com',
+            'maas.ubuntu.com',
+            'us.archive.ubuntu.com',
+            'uk.archive.ubuntu.com',
+            'foo.maas.ubuntu.com',
+            'archive.ubuntu.com',
+            'maas-xenial',
+            'juju-xenial',
+        )
+        self.assertThat(
+            sorted(names, key=preferred_hostnames_sort_key),
+            Equals([
+                'uk.archive.ubuntu.com',
+                'us.archive.ubuntu.com',
+                'foo.maas.ubuntu.com',
+                'archive.ubuntu.com',
+                'maas.ubuntu.com',
+                'www.ubuntu.com',
+                'juju-xenial',
+                'maas-xenial',
+            ])
+        )
+
+    def test__sorts_by_tlds_first(self):
+        names = (
+            'com.za',
+            'com.com',
+            'com.org',
+            'www.ubuntu.org',
+            'www.ubuntu.com',
+            'www.ubuntu.za',
+        )
+        self.assertThat(
+            sorted(names, key=preferred_hostnames_sort_key),
+            Equals([
+                'www.ubuntu.com',
+                'www.ubuntu.org',
+                'www.ubuntu.za',
+                'com.com',
+                'com.org',
+                'com.za',
+            ])
+        )
+
+    def test__ignores_trailing_periods(self):
+        names = (
+            'com.za.',
+            'com.com',
+            'com.org.',
+            'www.ubuntu.org',
+            'www.ubuntu.com.',
+            'www.ubuntu.za',
+        )
+        self.assertThat(
+            sorted(names, key=preferred_hostnames_sort_key),
+            Equals([
+                'www.ubuntu.com.',
+                'www.ubuntu.org',
+                'www.ubuntu.za',
+                'com.com',
+                'com.org.',
+                'com.za.',
+            ])
+        )
+
+
+class TestReverseResolveMixIn:
+    """Test fixture mix-in for unit tests calling `reverseResolve()`."""
+
+    def set_fake_twisted_dns_reply(self, hostnames: List[str]):
+        """Sets up the rrset data structure for the mock resolver.
+
+        This method must be called for any test cases in this suite which
+        intend to test the data being returned.
+        """
+        rrset = []
+        data = (rrset,)
+        for hostname in hostnames:
+            rr = Mock()
+            rr.payload = Mock()
+            rr.payload.name = Mock()
+            rr.payload.name.name = Mock()
+            rr.payload.name.name.decode = Mock()
+            rr.payload.name.name.decode.return_value = hostname
+            rrset.append(rr)
+        self.reply = data
+
+    @inlineCallbacks
+    def mock_lookupPointer(self, ip, timeout=None):
+        self.timeout = timeout
+        yield
+        return self.reply
+
+    def get_mock_iresolver(self):
+        resolver = Mock()
+        resolver.lookupPointer = Mock()
+        resolver.lookupPointer.side_effect = self.mock_lookupPointer
+        return resolver
+
+    def setUp(self):
+        super().setUp()
+        self.timeout = object()
+        self.getDefaultIResolver = self.patch(
+            network_module.getDefaultIResolver)
+        self.resolver = self.get_mock_iresolver()
+        self.lookupPointer = self.resolver.lookupPointer
+        self.getDefaultIResolver.return_value = self.resolver
+
+
+class TestReverseResolve(TestReverseResolveMixIn, MAASTestCase):
+    """Tests for `reverseResolve`."""
+
+    run_tests_with = MAASTwistedRunTest.make_factory(timeout=30)
+
+    @inlineCallbacks
+    def test__uses_resolver_from_getDefauldIResolver_by_default(self):
+        self.set_fake_twisted_dns_reply([])
+        yield reverseResolve(factory.make_ip_address())
+        self.assertThat(self.getDefaultIResolver, MockCalledOnceWith())
+
+    @inlineCallbacks
+    def test__uses_passed_in_IResolver_if_specified(self):
+        self.set_fake_twisted_dns_reply([])
+        some_other_resolver = self.get_mock_iresolver()
+        yield reverseResolve(
+            factory.make_ip_address(), resolver=some_other_resolver)
+        self.assertThat(self.getDefaultIResolver, MockNotCalled())
+        self.assertThat(some_other_resolver.lookupPointer, MockCalledOnce())
+
+    @inlineCallbacks
+    def test__returns_single_domain(self):
+        reverse_dns_reply = ['example.com']
+        self.set_fake_twisted_dns_reply(reverse_dns_reply)
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Equals(reverse_dns_reply))
+
+    @inlineCallbacks
+    def test__returns_multiple_sorted_domains(self):
+        reverse_dns_reply = ['ubuntu.com', 'example.com']
+        self.set_fake_twisted_dns_reply(reverse_dns_reply)
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Equals(
+            sorted(reverse_dns_reply, key=preferred_hostnames_sort_key)))
+
+    @inlineCallbacks
+    def test__empty_list_for_empty_rrset(self):
+        reverse_dns_reply = []
+        self.set_fake_twisted_dns_reply(reverse_dns_reply)
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Equals(reverse_dns_reply))
+
+    @inlineCallbacks
+    def test__returns_empty_list_for_domainerror(self):
+        self.lookupPointer.side_effect = DomainError
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Equals([]))
+
+    @inlineCallbacks
+    def test__returns_empty_list_for_authoritativedomainerror(self):
+        self.lookupPointer.side_effect = AuthoritativeDomainError
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Equals([]))
+
+    @inlineCallbacks
+    def test__returns_none_for_dnsquerytimeouterror(self):
+        self.lookupPointer.side_effect = DNSQueryTimeoutError(None)
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Is(None))
+
+    @inlineCallbacks
+    def test__returns_none_for_resolvererror(self):
+        self.lookupPointer.side_effect = ResolverError
+        result = yield reverseResolve(factory.make_ip_address())
+        self.expectThat(result, Is(None))
+
+    @inlineCallbacks
+    def test__raises_for_unhandled_error(self):
+        self.lookupPointer.side_effect = TypeError
+        with ExpectedException(TypeError):
+            yield reverseResolve(factory.make_ip_address())