further sketching

Signed-off-by: Matthias Büchse <[email protected]>

Author: mbuechse

Tests/kaas/plugin/interface.py

@@ -13,7 +13,7 @@ class KubernetesClusterPlugin():
     `kubeconfig_filepath`
 
     - Implement `create_cluster` and `delete_cluster` methods
-    - Create `__init__(self, config_file)` method to handle api specific
+    - Create `__init__(self, config, basepath)` method to handle api specific
       configurations.
 
     Example:
@@ -24,31 +24,28 @@ class KubernetesClusterPlugin():
 
           class PluginX(KubernetesClusterPlugin):
 
-              def __init__(self, config_file):
-                  self.config = config_file
+              def __init__(self, config, basepath):
+                  self.config = config
+                  self.basepath = basepath  # find other config files here
 
-              def create_cluster(self, cluster_name, version, kubeconfig_filepath):
-                  self.cluster = ClusterAPI(name=cluster_name, image=cluster_image, kubeconfig_filepath)
-                  self.cluster.create(self.config)
+              def create_cluster(self, kubeconfig_path):
+                  self.cluster = ClusterAPI(name=self.config['name'], kubeconfig_filepath)
+                  self.cluster.create()
 
               def delete_cluster(self, cluster_name):
-                  self.cluster = ClusterAPI(cluster_name)
+                  self.cluster = ClusterAPI(name=self.config['name'])
                   self.cluster.delete()
         ..
     """
 
-    def create_cluster(self, cluster_name, version, kubeconfig_filepath):
+    def create_cluster(self, kubeconfig_path: str):
         """
         This method is to be called to create a k8s cluster
-        :param: cluster_name:
-        :param: version:
-        :param: kubeconfig_filepath:
         """
         raise NotImplementedError
 
-    def delete_cluster(self, cluster_name):
+    def delete_cluster(self):
         """
         This method is to be called in order to unprovision a cluster
-        :param: cluster_name:
         """
         raise NotImplementedError

Tests/kaas/plugin/plugin_clusterstacks.py

@@ -0,0 +1,97 @@
+import base64
+import logging
+import os
+import os.path
+from pathlib import Path
+
+from interface import KubernetesClusterPlugin
+from jinja2 import Environment
+import kubernetes
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+TEMPLATE_KEYS = ('cluster', 'clusterstack', 'kubeconfig')
+
+
+def load_templates(env, basepath, fn_map, keys=TEMPLATE_KEYS):
+    new_map = {}
+    for key in keys:
+        fn = fn_map.get(key)
+        if fn is None:
+            new_map[key] = None
+            continue
+        with open(os.path.join(basepath, fn), "r") as fileobj:
+            new_map[key] = env.from_string(fileobj.read())
+    missing = [key for k, v in new_map.items() if v is None]
+    if missing:
+        raise RuntimeError(f'missing templates: {", ".join(missing)}')
+    return new_map
+
+
+class PluginClusterStacks(KubernetesClusterPlugin):
+    """
+    Plugin to handle the provisioning of kubernetes cluster for
+    conformance testing purpose with the use of Kind
+    """
+    def __init__(self, config, basepath='.', cwd='.'):
+        self.basepath = basepath
+        self.cwd = cwd
+        self.config = config
+        logger.debug(self.config)
+        self.env = Environment()
+        self.template_map = load_templates(self.env, self.basepath, self.config['templates'])
+        self.vars = self.config['vars']
+        self.vars['name'] = self.config['name']
+        self.secrets = self.config['secrets']
+        self.kubeconfig = yaml.load(
+            self.template_map['kubeconfig'].render(**self.vars, **self.secrets),
+            Loader=yaml.SafeLoader,
+        )
+        self.client_config = kubernetes.client.Configuration()
+        token = self.kubeconfig['users'][0]['user']['token']
+        self.client_config.api_key['authorization'] = 'Bearer {}'.format(token)
+        self.client_config.host = self.kubeconfig['clusters'][0]['cluster']['server']
+        self.client_config.ssl_ca_cert = os.path.abspath(os.path.join(self.cwd, 'ca.crt'))
+        with open(self.client_config.ssl_ca_cert, "wb") as fileobj:
+            fileobj.write(base64.standard_b64decode(self.kubeconfig['clusters'][0]['cluster']['certificate-authority-data'].encode()))
+        self.namespace = self.kubeconfig['contexts'][0]['context']['namespace']
+
+    def auto_vars_syself(self, api_client):
+        # beware: the following is quite the incantation
+        prefix = f"v{self.config['kubernetesVersion']}"
+        api_instance = kubernetes.client.CustomObjectsApi(api_client)
+        # mimic `kubectl get clusterstackrelease` (it's a bit more involved with the API)
+        res = api_instance.list_namespaced_custom_object('clusterstack.x-k8s.io', 'v1alpha1', self.namespace, 'clusterstackreleases')
+        # filter items by readiness and kubernetesVersion, select fields of interest: name, version
+        items = [
+          (item['metadata']['name'], item['status']['kubernetesVersion'])
+          for item in res['items']
+          if item['status']['ready']
+          if item['status']['kubernetesVersion'].startswith(prefix)
+        ]
+        # sort filtered result by patch version
+        items.sort(key=lambda item: item[1].rsplit('.', 1)[-1])
+        # select latest
+        cs_class_name, cs_version = items[-1]
+        self.vars.setdefault('cs_class_name', cs_class_name)
+        self.vars.setdefault('cs_version', cs_version)
+
+    def create_cluster(self):
+        with kubernetes.client.ApiClient(self.client_config) as api_client:
+            if self.config.get('autoVars') == 'syself':
+                self.auto_vars_syself(api_client)
+            # write out cluster.yaml for purposes of documentation; we won't use kubectl apply -f
+            cluster_yaml = self.template_map['cluster'].render(**self.vars)
+            cluster_dict = yaml.load(cluster_yaml, Loader=yaml.SafeLoader)
+            with open(os.path.join(self.cwd, 'cluster.yaml'), "w") as fileobj:
+                fileobj.write(cluster_yaml)
+            # kubernetes.utils.create_from_dict(api_client, cluster_dict)
+            api_instance = kubernetes.client.CustomObjectsApi(api_client)
+            # mimic `kubectl apply -f` (it's a bit more involved with the API)
+            res = api_instance.create_namespaced_custom_object('cluster.x-k8s.io', 'v1beta1', self.namespace, 'clusters', cluster_dict, field_manager='plugin_clusterstacks')
+
+    def delete_cluster(self):
+        cluster_name = self.config['name']
+        KindCluster(cluster_name).delete()

Tests/kaas/plugin/plugin_kind.py

@@ -14,18 +14,20 @@ class PluginKind(KubernetesClusterPlugin):
     Plugin to handle the provisioning of kubernetes cluster for
     conformance testing purpose with the use of Kind
     """
-    def __init__(self, config, basepath='.'):
+    def __init__(self, config, basepath='.', cwd='.'):
         self.basepath = basepath
+        self.cwd = cwd
         self.config = config
         logger.debug(self.config)
 
-    def create_cluster(self, kubeconfig_path):
+    def create_cluster(self):
         cluster_name = self.config['name']
         cluster_image = self.config['image']
         cluster_yaml = self.config.get('cluster')
         if cluster_yaml and not os.path.isabs(cluster_yaml):
             cluster_yaml = os.path.normpath(os.path.join(self.basepath, cluster_yaml))
-        cluster = KindCluster(name=cluster_name, image=cluster_image, kubeconfig=Path(kubeconfig_path))
+        kubeconfig = Path(os.path.join(self.cwd, 'kubeconfig.yaml'))
+        cluster = KindCluster(name=cluster_name, image=cluster_image, kubeconfig=kubeconfig)
         cluster.create(cluster_yaml)
 
     def delete_cluster(self):

Tests/kaas/plugin/run_plugin.py

@@ -5,11 +5,13 @@
 import click
 import yaml
 
+from plugin_clusterstacks import PluginClusterStacks
 from plugin_kind import PluginKind
 from plugin_static import PluginStatic
 
 
 PLUGIN_LOOKUP = {
+    "clusterstacks": PluginClusterStacks,
     "kind": PluginKind,
     "static": PluginStatic,
 }
@@ -30,11 +32,12 @@ def load_config(path='clusters.yaml'):
     return cfg
 
 
-def init_plugin(plugin_kind, config):
+def init_plugin(plugin_kind, config, cwd='.'):
     plugin_maker = PLUGIN_LOOKUP.get(plugin_kind)
     if plugin_maker is None:
         raise ValueError(f"unknown plugin '{plugin_kind}'")
-    return plugin_maker(config, basepath=BASEPATH)
+    os.makedirs(cwd, exist_ok=True)
+    return plugin_maker(config, basepath=BASEPATH, cwd=cwd)
 
 
 @click.group()
@@ -49,8 +52,8 @@ def create(cfg, cluster_id):
     spec = cfg['clusters'][cluster_id]
     config = spec['config']
     config['name'] = cluster_id
-    kubeconfig_path = os.path.abspath(os.path.join(cluster_id, 'kubeconfig.yaml'))
-    init_plugin(spec['kind'], config).create_cluster(kubeconfig_path)
+    cwd = os.path.abspath(cluster_id)
+    init_plugin(spec['kind'], config, cwd).create_cluster()
 
 
 @cli.command()
@@ -60,7 +63,8 @@ def delete(cfg, cluster_id):
     spec = cfg['clusters'][cluster_id]
     config = spec['config']
     config['name'] = cluster_id
-    init_plugin(spec['kind'], config).delete_cluster()
+    cwd = os.path.abspath(cluster_id)
+    init_plugin(spec['kind'], config, cwd).delete_cluster()
 
 
 if __name__ == '__main__':

Tests/kaas/requirements.in

@@ -1,3 +1,4 @@
 pytest-kind
 kubernetes
+jinja2
 junitparser