Merge lp:~allenap/maas/rpc-get-preseed-data-helper into lp:~maas-committers/maas/trunk

[Gavin Panella]

Helper function to call GetPreseedData on the cluster from the region.

Also cleans up several implementations of make_url().

[Raphaël Badin (rvb)]

review: Approve

[Gavin Panella (allenap)]

Thanks for the review!

=== modified file 'src/apiclient/tests/test_maas_client.py'
--- src/apiclient/tests/test_maas_client.py	2014-07-16 14:12:13 +0000
+++ src/apiclient/tests/test_maas_client.py	2014-07-24 15:53:02 +0000
@@ -138,14 +138,6 @@
         self.assertEqual(content, read_content)
 
 
-def make_url():
-    """Create an arbitrary URL."""
-    return 'http://example.com:%d/%s/' % (
-        factory.pick_port(),
-        factory.make_string(),
-        )
-
-
 def make_path():
     """Create an arbitrary resource path."""
     return "/" + '/'.join(factory.make_string() for counter in range(2))
@@ -172,7 +164,8 @@
 def make_client(root=None, result=None):
     """Create a MAASClient."""
     if root is None:
-        root = make_url()
+        root = factory.make_simple_http_url(
+            path=factory.make_name("path") + "/")
     auth = MAASOAuth(
         factory.make_string(), factory.make_string(),
         factory.make_string())
 
=== modified file 'src/maasserver/clusterrpc/osystems.py'
--- src/maasserver/clusterrpc/osystems.py	2014-07-16 22:11:14 +0000
+++ src/maasserver/clusterrpc/osystems.py	2014-07-24 15:53:02 +0000
@@ -14,14 +14,23 @@
 __metaclass__ = type
 __all__ = [
     "gen_all_known_operating_systems",
+    "get_preseed_data",
 ]
 
 from collections import defaultdict
 from functools import partial
+from urlparse import urlparse
 
-from maasserver.rpc import getAllClients
+from maasserver.rpc import (
+    getAllClients,
+    getClientFor,
+    )
 from maasserver.utils import async
-from provisioningserver.rpc.cluster import ListOperatingSystems
+from provisioningserver.rpc.cluster import (
+    GetPreseedData,
+    ListOperatingSystems,
+    )
+from provisioningserver.utils import synchronous
 from twisted.python.failure import Failure
 
 
@@ -35,6 +44,7 @@
             yield response
 
 
+@synchronous
 def gen_all_known_operating_systems():
     """Generator yielding details on OSes supported by any cluster.
 
@@ -52,3 +62,31 @@
             if osystem not in seen[name]:
                 seen[name].append(osystem)
                 yield osystem
+
+
+@synchronous
+def get_preseed_data(preseed_type, node, token, metadata_url):
+    """Obtain optional preseed data for this OS, preseed type, and node.
+
+    :param preseed_type: The type of preseed to compose.
+    :param node: The node model instance.
+    :param token: The token model instance.
+    :param metadata_url: The URL where this node's metadata will be made
+        available.
+
+    :raises NoConnectionsAvailable: When no connections to the node's
+        cluster are available for use.
+    :raises NoSuchOperatingSystem: When the node's declared operating
+        system is not known to its cluster.
+    :raises NotImplementedError: When this node's OS does not want to
+        define any OS-specific preseed data.
+    :raises TimeoutError: If a response has not been received within 30
+        seconds.
+    """
+    client = getClientFor(node.nodegroup.uuid).wait(5)
+    call = client(
+        GetPreseedData, osystem=node.get_osystem(), preseed_type=preseed_type,
+        node_system_id=node.system_id, node_hostname=node.hostname,
+        consumer_key=token.consumer.key, token_key=token.key,
+        token_secret=token.secret, metadata_url=urlparse(metadata_url))
+    return call.wait(30)
 
=== modified file 'src/maasserver/clusterrpc/tests/test_osystems.py'
--- src/maasserver/clusterrpc/tests/test_osystems.py	2014-07-21 12:28:45 +0000
+++ src/maasserver/clusterrpc/tests/test_osystems.py	2014-07-24 15:53:02 +0000
@@ -20,12 +20,18 @@
     )
 
 from maasserver import eventloop
-from maasserver.clusterrpc.osystems import gen_all_known_operating_systems
+from maasserver.clusterrpc.osystems import (
+    gen_all_known_operating_systems,
+    get_preseed_data,
+    )
+from maasserver.enum import PRESEED_TYPE
 from maasserver.rpc import getAllClients
 from maasserver.rpc.testing.fixtures import ClusterRPCFixture
 from maasserver.testing.eventloop import RegionEventLoopFixture
 from maasserver.testing.factory import factory
 from maasserver.testing.testcase import MAASServerTestCase
+from metadataserver.models import NodeKey
+from provisioningserver.rpc.exceptions import NoSuchOperatingSystem
 from testtools.matchers import (
     AfterPreprocessing,
     AllMatch,
@@ -37,21 +43,22 @@
 from twisted.internet.defer import succeed
 
 
+def fake_cluster_rpc(test):
+    # Set-up the event-loop with only the RPC service running, then
+    # layer on a fake cluster RPC implementation.
+    test.useFixture(RegionEventLoopFixture("rpc"))
+    test.addCleanup(lambda: eventloop.reset().wait(5))
+    eventloop.start().wait(5)
+    test.useFixture(ClusterRPCFixture())
+
+
 class TestGenAllKnownOperatingSystems(MAASServerTestCase):
     """Tests for `gen_all_known_operating_systems`."""
 
-    def fake_cluster_rpc(self):
-        # Set-up the event-loop with only the RPC service running, then
-        # layer on a fake cluster RPC implementation.
-        self.useFixture(RegionEventLoopFixture("rpc"))
-        self.addCleanup(lambda: eventloop.reset().wait(5))
-        eventloop.start().wait(5)
-        self.useFixture(ClusterRPCFixture())
-
     def test_yields_oses_known_to_a_cluster(self):
         # The operating systems known to a single node are returned.
         factory.make_node_group().accept()
-        self.fake_cluster_rpc()
+        fake_cluster_rpc(self)
         osystems = gen_all_known_operating_systems()
         self.assertIsInstance(osystems, Iterator)
         osystems = list(osystems)
@@ -61,7 +68,7 @@
     def test_yields_oses_known_to_multiple_clusters(self):
         factory.make_node_group().accept()
         factory.make_node_group().accept()
-        self.fake_cluster_rpc()
+        fake_cluster_rpc(self)
         osystems = gen_all_known_operating_systems()
         self.assertIsInstance(osystems, Iterator)
         osystems = list(osystems)
@@ -73,7 +80,7 @@
         # every cluster will have several (or all) OSes in common.
         factory.make_node_group().accept()
         factory.make_node_group().accept()
-        self.fake_cluster_rpc()
+        fake_cluster_rpc(self)
         counter = Counter(
             osystem["name"] for osystem in
             gen_all_known_operating_systems())
@@ -88,7 +95,7 @@
 
     def test_os_data_is_passed_through_unmolested(self):
         factory.make_node_group().accept()
-        self.fake_cluster_rpc()
+        fake_cluster_rpc(self)
         example = {
             "osystems": [
                 {
@@ -109,7 +116,7 @@
         factory.make_node_group().accept()
         factory.make_node_group().accept()
         factory.make_node_group().accept()
-        self.fake_cluster_rpc()
+        fake_cluster_rpc(self)
 
         clients = getAllClients().wait()
         for index, client in enumerate(clients):
@@ -129,3 +136,39 @@
         self.assertItemsEqual(
             [{"name": clients[0].ident}],
             gen_all_known_operating_systems())
+
+
+class TestGetPreseedData(MAASServerTestCase):
+    """Tests for `get_preseed_data`."""
+
+    def test_returns_preseed_data(self):
+        # The Windows driver is known to provide custom preseed data.
+        node = factory.make_node(osystem="windows")
+        node.nodegroup.accept()
+        fake_cluster_rpc(self)
+        preseed_data = get_preseed_data(
+            PRESEED_TYPE.COMMISSIONING, node,
+            token=NodeKey.objects.get_token_for_node(node),
+            metadata_url=factory.make_url())
+        self.assertThat(preseed_data, IsInstance(dict))
+        self.assertThat(preseed_data, Not(HasLength(0)))
+
+    def test_propagates_NotImplementedError(self):
+        # The Windows driver is known to *not* provide custom preseed
+        # data when using Curtin.
+        node = factory.make_node(osystem="windows")
+        node.nodegroup.accept()
+        fake_cluster_rpc(self)
+        self.assertRaises(
+            NotImplementedError, get_preseed_data, PRESEED_TYPE.CURTIN,
+            node, token=NodeKey.objects.get_token_for_node(node),
+            metadata_url=factory.make_url())
+
+    def test_propagates_NoSuchOperatingSystem(self):
+        node = factory.make_node(osystem=factory.make_name("foo"))
+        node.nodegroup.accept()
+        fake_cluster_rpc(self)
+        self.assertRaises(
+            NoSuchOperatingSystem, get_preseed_data, PRESEED_TYPE.CURTIN,
+            node, token=NodeKey.objects.get_token_for_node(node),
+            metadata_url=factory.make_url())
 
=== modified file 'src/maasserver/tests/test_preseed.py'
--- src/maasserver/tests/test_preseed.py	2014-07-18 15:44:55 +0000
+++ src/maasserver/tests/test_preseed.py	2014-07-24 15:53:02 +0000
@@ -442,14 +442,6 @@
             pick_cluster_controller_address(node))
 
 
-def make_url(name):
-    """Create a fake archive URL."""
-    return "http://%s.example.com/%s/" % (
-        factory.make_name(name),
-        factory.make_name('path'),
-        )
-
-
 class TestPreseedContext(MAASServerTestCase):
     """Tests for `get_preseed_context`."""
 
@@ -467,8 +459,8 @@
     def test_get_preseed_context_archive_refs(self):
         # urlparse lowercases the hostnames. That should not have any
         # impact but for testing, create lower-case hostnames.
-        main_archive = make_url('main_archive')
-        ports_archive = make_url('ports_archive')
+        main_archive = factory.make_url(netloc="main-archive.example.com")
+        ports_archive = factory.make_url(netloc="ports-archive.example.com")
         Config.objects.set_config('main_archive', main_archive)
         Config.objects.set_config('ports_archive', ports_archive)
         nodegroup = factory.make_node_group(maas_url=factory.make_string())
 
=== modified file 'src/maastesting/factory.py'
--- src/maastesting/factory.py	2014-07-16 14:12:13 +0000
+++ src/maastesting/factory.py	2014-07-24 15:53:02 +0000
@@ -322,23 +322,59 @@
         scheme for scheme in urlparse.uses_params
         if scheme != "")
 
-    def make_parsed_url(self):
+    def make_parsed_url(
+            self, scheme=None, netloc=None, path=None, params=None,
+            query=None, fragment=None):
         """Generate a random parsed URL object.
 
+        Contains randomly generated values for all parts of a URL: scheme,
+        location, path, parameters, query, and fragment. However, each part
+        can be overridden individually.
+
         :return: Instance of :py:class:`urlparse.ParseResult`.
         """
-        return urlparse.ParseResult(
+        if scheme is None:
             # Select a scheme that allows parameters; see above.
-            random.choice(self._make_parsed_url_schemes),
-            self.make_name("netloc").lower(),
+            scheme = random.choice(self._make_parsed_url_schemes)
+        if netloc is None:
+            netloc = "%s.example.com" % self.make_name("netloc").lower()
+        if path is None:
             # A leading forward-slash will be added in geturl() if we
             # don't, so ensure it's here now so tests can compare URLs
             # without worrying about it.
-            self.make_name("/path"),
-            self.make_name("params"),
-            self.make_name("query"),
-            self.make_name("fragment"),
-        )
+            path = self.make_name("/path")
+        else:
+            # Same here with the forward-slash prefix.
+            if not path.startswith("/"):
+                path = "/" + path
+        if params is None:
+            params = self.make_name("params")
+        if query is None:
+            query = self.make_name("query")
+        if fragment is None:
+            fragment = self.make_name("fragment")
+        return urlparse.ParseResult(
+            scheme, netloc, path, params, query, fragment)
+
+    def make_url(
+            self, scheme=None, netloc=None, path=None, params=None,
+            query=None, fragment=None):
+        """Generate a random URL.
+
+        Contains randomly generated values for all parts of a URL: scheme,
+        location, path, parameters, query, and fragment. However, each part
+        can be overridden individually.
+
+        :return: string
+        """
+        return self.make_parsed_url(
+            scheme, netloc, path, params, query, fragment).geturl()
+
+    def make_simple_http_url(self, netloc=None, path=None):
+        """Create an arbitrary HTTP URL with only a location and path."""
+        return self.make_parsed_url(
+            scheme="http", netloc=netloc, path=path, params="", query="",
+            fragment="").geturl()
 
     def make_names(self, *prefixes):
         """Generate random names.