Add a stub cluster_api driver

The plan is to slowly build up the ability to create K8s CRDs
instead of heat templates in a separate driver.
The starting point is adding the new experimental driver.

story: 2009780

Change-Id: I32b7a91640f4f65b9662de080682761a2c182055

magnum/drivers/cluster_api/driver.py

@@ -0,0 +1,85 @@
+# Licensed under the Apache License, Version 2.0 (the "License"); you may
+# not use this file except in compliance with the License. You may obtain
+# a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+# License for the specific language governing permissions and limitations
+# under the License.
+
+from oslo_log import log as logging
+
+from magnum.drivers.common import driver
+
+LOG = logging.getLogger(__name__)
+
+
+class Driver(driver.Driver):
+    @property
+    def provides(self):
+        return [
+            {
+                "server_type": "vm",
+                # TODO(johngarbutt) OS list should probably come from config?
+                "os": "ubuntu",
+                "coe": "kubernetes",
+            },
+        ]
+
+    def update_cluster_status(self, context, cluster):
+        raise NotImplementedError("don't support update_cluster_status yet")
+
+    def create_cluster(self, context, cluster, cluster_create_timeout):
+        raise NotImplementedError("don't support create yet")
+
+    def update_cluster(
+        self, context, cluster, scale_manager=None, rollback=False
+    ):
+        raise NotImplementedError("don't support update yet")
+
+    def delete_cluster(self, context, cluster):
+        raise NotImplementedError("don't support delete yet")
+
+    def resize_cluster(
+        self,
+        context,
+        cluster,
+        resize_manager,
+        node_count,
+        nodes_to_remove,
+        nodegroup=None,
+    ):
+        raise NotImplementedError("don't support removing nodes this way yet")
+
+    def upgrade_cluster(
+        self,
+        context,
+        cluster,
+        cluster_template,
+        max_batch_size,
+        nodegroup,
+        scale_manager=None,
+        rollback=False,
+    ):
+        raise NotImplementedError("don't support upgrade yet")
+
+    def create_nodegroup(self, context, cluster, nodegroup):
+        raise NotImplementedError("we don't support node groups yet")
+
+    def update_nodegroup(self, context, cluster, nodegroup):
+        raise NotImplementedError("we don't support node groups yet")
+
+    def delete_nodegroup(self, context, cluster, nodegroup):
+        raise NotImplementedError("we don't support node groups yet")
+
+    def create_federation(self, context, federation):
+        raise NotImplementedError("Will not implement 'create_federation'")
+
+    def update_federation(self, context, federation):
+        raise NotImplementedError("Will not implement 'update_federation'")
+
+    def delete_federation(self, context, federation):
+        raise NotImplementedError("Will not implement 'delete_federation'")

magnum/tests/unit/drivers/cluster_api/test_driver.py

@@ -0,0 +1,139 @@
+#    Licensed under the Apache License, Version 2.0 (the "License"); you may
+#    not use this file except in compliance with the License. You may obtain
+#    a copy of the License at
+#
+#         http://www.apache.org/licenses/LICENSE-2.0
+#
+#    Unless required by applicable law or agreed to in writing, software
+#    distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
+#    WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
+#    License for the specific language governing permissions and limitations
+#    under the License.
+from magnum.drivers.cluster_api import driver
+from magnum import objects
+from magnum.tests.unit.db import base
+from magnum.tests.unit.objects import utils as obj_utils
+
+
+class ClusterAPIDriverTest(base.DbTestCase):
+    def setUp(self):
+        super(ClusterAPIDriverTest, self).setUp()
+        self.driver = driver.Driver()
+        self.cluster_obj = obj_utils.create_test_cluster(
+            self.context,
+            name="cluster_example_$A",
+            master_flavor_id="flavor_small",
+            flavor_id="flavor_medium",
+        )
+
+    def test_provides(self):
+        self.assertEqual(
+            [{"server_type": "vm", "os": "ubuntu", "coe": "kubernetes"}],
+            self.driver.provides,
+        )
+
+    def test_update_cluster_status(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.update_cluster_status,
+            self.context,
+            self.cluster_obj,
+        )
+
+    def test_create_cluster(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.create_cluster,
+            self.context,
+            self.cluster_obj,
+            cluster_create_timeout=10,
+        )
+
+    def test_delete_cluster(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.delete_cluster,
+            self.context,
+            self.cluster_obj,
+        )
+
+    def test_update_cluster(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.update_cluster,
+            self.context,
+            self.cluster_obj,
+        )
+
+    def test_resize_cluster(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.resize_cluster,
+            self.context,
+            self.cluster_obj,
+            None,
+            4,
+            None,
+        )
+
+    def test_upgrade_cluster(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.upgrade_cluster,
+            self.context,
+            self.cluster_obj,
+            self.cluster_obj.cluster_template,
+            1,
+            None,
+        )
+
+    def test_create_nodegroup(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.create_nodegroup,
+            self.context,
+            self.cluster_obj,
+            objects.NodeGroup(),
+        )
+
+    def test_update_nodegroup(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.update_nodegroup,
+            self.context,
+            self.cluster_obj,
+            objects.NodeGroup(),
+        )
+
+    def test_delete_nodegroup(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.delete_nodegroup,
+            self.context,
+            self.cluster_obj,
+            objects.NodeGroup(),
+        )
+
+    def test_create_federation(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.create_federation,
+            self.context,
+            None,
+        )
+
+    def test_update_federation(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.update_federation,
+            self.context,
+            None,
+        )
+
+    def test_delete_federation(self):
+        self.assertRaises(
+            NotImplementedError,
+            self.driver.delete_federation,
+            self.context,
+            None,
+        )

magnum/tests/unit/drivers/test_template_definition.py

@@ -20,6 +20,7 @@ import six
 
 from magnum.common import exception
 import magnum.conf
+from magnum.drivers.cluster_api import driver as cluster_api_driver
 from magnum.drivers.common import driver
 from magnum.drivers.heat import template_def as cmn_tdef
 from magnum.drivers.k8s_coreos_v1 import driver as k8s_coreos_dr
@@ -55,6 +56,13 @@ class TemplateDefinitionTestCase(base.TestCase):
             self.assertEqual(expected_entry_point, actual_entry_point)
             expected_entry_point.load.assert_called_once_with(require=False)
 
+    def test_get_vm_cluster_api_k8s_driver(self):
+        # NOTE(johngarbutt) covered by above test, but I wanted to be explict
+        cluster_driver = driver.Driver.get_driver('vm',
+                                                  'ubuntu',
+                                                  'kubernetes')
+        self.assertIsInstance(cluster_driver, cluster_api_driver.Driver)
+
     @mock.patch('magnum.drivers.common.driver.Driver.get_driver')
     def test_get_vm_atomic_kubernetes_definition(self, mock_driver):
         mock_driver.return_value = k8sa_dr.Driver()

setup.cfg

@@ -55,6 +55,7 @@ magnum.drivers =
     swarm_fedora_atomic_v1 = magnum.drivers.swarm_fedora_atomic_v1.driver:Driver
     swarm_fedora_atomic_v2 = magnum.drivers.swarm_fedora_atomic_v2.driver:Driver
     k8s_fedora_ironic_v1 = magnum.drivers.k8s_fedora_ironic_v1.driver:Driver
+    k8s_cluster_api_v1 = magnum.drivers.cluster_api.driver:Driver
 
 magnum.database.migration_backend =
     sqlalchemy = magnum.db.sqlalchemy.migration