Generate names for K8s pods when file or url

[osm/N2VC.git] / n2vc / k8s_juju_conn.py

diff --git a/n2vc/k8s_juju_conn.py b/n2vc/k8s_juju_conn.py
index 1f7cc00..1db34b4 100644 (file)
--- a/n2vc/k8s_juju_conn.py
+++ b/n2vc/k8s_juju_conn.py
@@ -12,9 +12,11 @@
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 
 #     See the License for the specific language governing permissions and
 #     limitations under the License.
 

+import asyncio

 import concurrent
 from .exceptions import NotImplemented
 
 import concurrent
 from .exceptions import NotImplemented
 

+import io

 import juju
 # from juju.bundle import BundleHandler
 from juju.controller import Controller
 import juju
 # from juju.bundle import BundleHandler
 from juju.controller import Controller


@@ -28,7 +30,6 @@ from n2vc.k8s_conn import K8sConnector
 import os
 # import re
 # import ssl
 import os
 # import re
 # import ssl

-import subprocess

 # from .vnf import N2VC
 
 import uuid
 # from .vnf import N2VC
 
 import uuid


@@ -123,10 +124,11 @@ class K8sJujuConnector(K8sConnector):
 
             cluster_uuid = str(uuid.uuid4())
 
 
             cluster_uuid = str(uuid.uuid4())
 

-            # Add k8s cloud to Juju (unless it's microk8s)
+            # Is a local k8s cluster?
+            localk8s = self.is_local_k8s(k8s_creds)

 
 

-            # Does the kubeconfig contain microk8s?
-            microk8s = self.is_microk8s_by_credentials(k8s_creds)
+            # If the k8s is external, the juju controller needs a loadbalancer
+            loadbalancer = False if localk8s else True

 
             # Name the new k8s cloud
             k8s_cloud = "{}-k8s".format(namespace)
 
             # Name the new k8s cloud
             k8s_cloud = "{}-k8s".format(namespace)


@@ -136,7 +138,7 @@ class K8sJujuConnector(K8sConnector):
 
             # Bootstrap Juju controller
             print("Bootstrapping...")
 
             # Bootstrap Juju controller
             print("Bootstrapping...")

-            await self.bootstrap(k8s_cloud, cluster_uuid, microk8s)
+            await self.bootstrap(k8s_cloud, cluster_uuid, loadbalancer)

             print("Bootstrap done.")
 
             # Get the controller information
             print("Bootstrap done.")
 
             # Get the controller information


@@ -180,7 +182,7 @@ class K8sJujuConnector(K8sConnector):
                 'secret': self.juju_secret,
                 'cacert': self.juju_ca_cert,
                 'namespace': namespace,
                 'secret': self.juju_secret,
                 'cacert': self.juju_ca_cert,
                 'namespace': namespace,

-                'microk8s': microk8s,
+                'loadbalancer': loadbalancer,

             }
 
             # Store the cluster configuration so it
             }
 
             # Store the cluster configuration so it


@@ -207,7 +209,7 @@ class K8sJujuConnector(K8sConnector):
         # We're creating a new cluster
         print("Getting model {}".format(self.get_namespace(cluster_uuid), cluster_uuid=cluster_uuid))
         model = await self.get_model(
         # We're creating a new cluster
         print("Getting model {}".format(self.get_namespace(cluster_uuid), cluster_uuid=cluster_uuid))
         model = await self.get_model(

-            self.get_namespace(cluster_uuid), 
+            self.get_namespace(cluster_uuid),

             cluster_uuid=cluster_uuid
         )
 
             cluster_uuid=cluster_uuid
         )
 


@@ -272,13 +274,6 @@ class K8sJujuConnector(K8sConnector):
                 print("[reset] Destroying controller")
                 await self.destroy_controller(cluster_uuid)
 
                 print("[reset] Destroying controller")
                 await self.destroy_controller(cluster_uuid)
 

-                """Remove the k8s cloud
-
-                Only remove the k8s cloud if it's not a microk8s cloud,
-                since microk8s is a built-in cloud type.
-                """
-                # microk8s = self.is_microk8s_by_cluster_uuid(cluster_uuid)
-                # if not microk8s:

                 print("[reset] Removing k8s cloud")
                 namespace = self.get_namespace(cluster_uuid)
                 k8s_cloud = "{}-k8s".format(namespace)
                 print("[reset] Removing k8s cloud")
                 namespace = self.get_namespace(cluster_uuid)
                 k8s_cloud = "{}-k8s".format(namespace)


@@ -316,16 +311,16 @@ class K8sJujuConnector(K8sConnector):
             await self.login(cluster_uuid)
 
         ##
             await self.login(cluster_uuid)
 
         ##

-        # Get or create the model, based on the namespace the cluster was
-        # instantiated with.
-        namespace = self.get_namespace(cluster_uuid)
+        # Get or create the model, based on the NS
+        # uuid.
+        model_name = db_dict["filter"]["_id"]

 
 

-        self.log.debug("Checking for model named {}".format(namespace))
-        model = await self.get_model(namespace, cluster_uuid=cluster_uuid)
+        self.log.debug("Checking for model named {}".format(model_name))
+        model = await self.get_model(model_name, cluster_uuid=cluster_uuid)

         if not model:
             # Create the new model
         if not model:
             # Create the new model

-            self.log.debug("Adding model: {}".format(namespace))
-            model = await self.add_model(namespace, cluster_uuid=cluster_uuid)
+            self.log.debug("Adding model: {}".format(model_name))
+            model = await self.add_model(model_name, cluster_uuid=cluster_uuid)

 
         if model:
             # TODO: Instantiation parameters
 
         if model:
             # TODO: Instantiation parameters


@@ -657,19 +652,28 @@ class K8sJujuConnector(K8sConnector):
 
         cmd = [self.juju_command, "add-k8s", "--local", cloud_name]
         print(cmd)
 
         cmd = [self.juju_command, "add-k8s", "--local", cloud_name]
         print(cmd)

-        p = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            # input=yaml.dump(credentials, Dumper=yaml.Dumper).encode("utf-8"),
-            input=credentials.encode("utf-8"),
-            # encoding='ascii'
+
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+            stdin=asyncio.subprocess.PIPE,

         )
         )

-        retcode = p.returncode
-        print("add-k8s return code: {}".format(retcode))

 
 

-        if retcode > 0:
-            raise Exception(p.stderr)
+        # Feed the process the credentials
+        process.stdin.write(credentials.encode("utf-8"))
+        await process.stdin.drain()
+        process.stdin.close()
+
+        stdout, stderr = await process.communicate()
+
+        return_code = process.returncode
+
+        print("add-k8s return code: {}".format(return_code))
+
+        if return_code > 0:
+            raise Exception(stderr)
+

         return True
 
     async def add_model(
         return True
 
     async def add_model(


@@ -699,7 +703,7 @@ class K8sJujuConnector(K8sConnector):
         self,
         cloud_name: str,
         cluster_uuid: str,
         self,
         cloud_name: str,
         cluster_uuid: str,

-        microk8s: bool
+        loadbalancer: bool

     ) -> bool:
         """Bootstrap a Kubernetes controller
 
     ) -> bool:
         """Bootstrap a Kubernetes controller
 


@@ -707,15 +711,15 @@ class K8sJujuConnector(K8sConnector):
 
         :param cloud_name str: The name of the cloud.
         :param cluster_uuid str: The UUID of the cluster to bootstrap.
 
         :param cloud_name str: The name of the cloud.
         :param cluster_uuid str: The UUID of the cluster to bootstrap.

-        :param microk8s bool: If this is a microk8s cluster.
+        :param loadbalancer bool: If the controller should use loadbalancer or not.

         :returns: True upon success or raises an exception.
         """
 
         :returns: True upon success or raises an exception.
         """
 

-        if microk8s:
+        if not loadbalancer:

             cmd = [self.juju_command, "bootstrap", cloud_name, cluster_uuid]
         else:
             """
             cmd = [self.juju_command, "bootstrap", cloud_name, cluster_uuid]
         else:
             """

-            For non-microk8s clusters, specify that the controller service is using a LoadBalancer.
+            For public clusters, specify that the controller service is using a LoadBalancer.

             """
             cmd = [self.juju_command, "bootstrap", cloud_name, cluster_uuid, "--config", "controller-service-type=loadbalancer"]
 
             """
             cmd = [self.juju_command, "bootstrap", cloud_name, cluster_uuid, "--config", "controller-service-type=loadbalancer"]
 


@@ -723,18 +727,20 @@ class K8sJujuConnector(K8sConnector):
             cluster_uuid, cloud_name
         ))
 
             cluster_uuid, cloud_name
         ))
 

-        p = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            # encoding='ascii'
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,

         )
         )

-        retcode = p.returncode

 
 

-        if retcode > 0:
+        stdout, stderr = await process.communicate()
+
+        return_code = process.returncode
+
+        if return_code > 0:

             #
             #

-            if b'already exists' not in p.stderr:
-                raise Exception(p.stderr)
+            if b'already exists' not in stderr:
+                raise Exception(stderr)

 
         return True
 
 
         return True
 


@@ -758,18 +764,20 @@ class K8sJujuConnector(K8sConnector):
             cluster_uuid
         ]
 
             cluster_uuid
         ]
 

-        p = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            # encoding='ascii'
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,

         )
         )

-        retcode = p.returncode

 
 

-        if retcode > 0:
+        stdout, stderr = await process.communicate()
+
+        return_code = process.returncode
+
+        if return_code > 0:

             #
             #

-            if 'already exists' not in p.stderr:
-                raise Exception(p.stderr)
+            if 'already exists' not in stderr:
+                raise Exception(stderr)

 
     def get_config(
         self,
 
     def get_config(
         self,


@@ -858,36 +866,26 @@ class K8sJujuConnector(K8sConnector):
             return True
         return False
 
             return True
         return False
 

-    def is_microk8s_by_cluster_uuid(
-        self,
-        cluster_uuid: str,
-    ) -> bool:
-        """Check if a cluster is micro8s
-
-        Checks if a cluster is running microk8s
-
-        :param cluster_uuid str: The UUID of the cluster
-        :returns: A boolean if the cluster is running microk8s
-        """
-        config = self.get_config(cluster_uuid)
-        return config['microk8s']
-
-    def is_microk8s_by_credentials(
+    def is_local_k8s(

         self,
         credentials: str,
     ) -> bool:
         self,
         credentials: str,
     ) -> bool:

-        """Check if a cluster is micro8s
+        """Check if a cluster is local

 
 

-        Checks if a cluster is running microk8s
+        Checks if a cluster is running in the local host

 
         :param credentials dict: A dictionary containing the k8s credentials
 
         :param credentials dict: A dictionary containing the k8s credentials

-        :returns: A boolean if the cluster is running microk8s
+        :returns: A boolean if the cluster is running locally

         """
         creds = yaml.safe_load(credentials)
         """
         creds = yaml.safe_load(credentials)

-        if creds:
-            for context in creds['contexts']:
-                if 'microk8s' in context['name']:
-                    return True
+        if os.getenv("OSMLCM_VCA_APIPROXY"):
+            host_ip = os.getenv("OSMLCM_VCA_APIPROXY")
+
+        if creds and host_ip:
+            for cluster in creds['clusters']:
+                if 'server' in cluster['cluster']:
+                    if host_ip in cluster['cluster']['server']:
+                        return True

 
         return False
 
 
         return False
 


@@ -969,30 +967,33 @@ class K8sJujuConnector(K8sConnector):
 
         # Remove the bootstrapped controller
         cmd = [self.juju_command, "remove-k8s", "--client", cloud_name]
 
         # Remove the bootstrapped controller
         cmd = [self.juju_command, "remove-k8s", "--client", cloud_name]

-        p = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            # encoding='ascii'
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,

         )
         )

-        retcode = p.returncode

 
 

-        if retcode > 0:
-            raise Exception(p.stderr)
+        stdout, stderr = await process.communicate()
+
+        return_code = process.returncode
+
+        if return_code > 0:
+            raise Exception(stderr)

 
         # Remove the cloud from the local config
         cmd = [self.juju_command, "remove-cloud", "--client", cloud_name]
 
         # Remove the cloud from the local config
         cmd = [self.juju_command, "remove-cloud", "--client", cloud_name]

-        p = subprocess.run(
-            cmd,
-            stdout=subprocess.PIPE,
-            stderr=subprocess.PIPE,
-            # encoding='ascii'
+        process = await asyncio.create_subprocess_exec(
+            *cmd,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,

         )
         )

-        retcode = p.returncode

 
 

-        if retcode > 0:
-            raise Exception(p.stderr)
+        stdout, stderr = await process.communicate()
+
+        return_code = process.returncode

 
 

+        if return_code > 0:
+            raise Exception(stderr)

 
         return True
 
 
         return True