Move functions with creation of SC, PVC and POD objects to common place

Removing duplication of code.
Also, reuse it in places where it is already duplicated.

Change-Id: I2f88b4921cb7bec01d17e1ddeaeda16e0d198493

1 files changed, 151 insertions, 1 deletions

diff --git a/cns-libs/cnslibs/cns/cns_baseclass.py b/cns-libs/cnslibs/cns/cns_baseclass.py
index 4f84061c..5dfe430c 100644
--- a/cns-libs/cnslibs/cns/cns_baseclass.py
+++ b/cns-libs/cnslibs/cns/cns_baseclass.py
@@ -4,7 +4,9 @@ from cnslibs.common.exceptions import (
     ConfigError,
     ExecutionError)
 from cnslibs.common.heketi_ops import (
+    heketi_blockvolume_delete,
     heketi_create_topology,
+    heketi_volume_delete,
     hello_heketi)
 from cnslibs.common.cns_libs import (
     edit_iptables_cns,
@@ -21,7 +23,20 @@ from cnslibs.common.docker_libs import (
 from cnslibs.common.openshift_ops import (
     create_namespace,
     get_ocp_gluster_pod_names,
-    oc_rsh)
+    get_pod_name_from_dc,
+    get_pv_name_from_pvc,
+    oc_create_app_dc_with_io,
+    oc_create_pvc,
+    oc_create_sc,
+    oc_create_secret,
+    oc_delete,
+    oc_get_custom_resource,
+    oc_rsh,
+    scale_dc_pod_amount_and_wait,
+    verify_pvc_status_is_bound,
+    wait_for_pod_be_ready,
+    wait_for_resource_absence,
+)
 import datetime
 from glusto.core import Glusto as g
 import unittest
@@ -98,6 +113,8 @@ class CnsBaseClass(unittest.TestCase):
 
         cls.cns_storage_class = (g.config['cns']['dynamic_provisioning']
                                  ['storage_classes'])
+        cls.sc = cls.cns_storage_class.get(
+            'storage_class1', cls.cns_storage_class.get('file_storage_class'))
         cmd = "echo -n %s | base64" % cls.heketi_cli_key
         ret, out, err = g.run(cls.ocp_master_node[0], cmd, "root")
         if ret != 0:
@@ -142,6 +159,136 @@ class CnsBaseClass(unittest.TestCase):
         return command.cmd_run(
             cmd=cmd, hostname=hostname, raise_on_error=raise_on_error)
 
+    def create_secret(self, secret_name_prefix="autotests-secret-"):
+        secret_name = oc_create_secret(
+            self.ocp_client[0],
+            secret_name_prefix=secret_name_prefix,
+            namespace=(self.sc.get(
+                'secretnamespace',
+                self.sc.get('restsecretnamespace', 'default'))),
+            data_key=self.heketi_cli_key,
+            secret_type=self.sc.get('provisioner', 'kubernetes.io/glusterfs'))
+        self.addCleanup(
+            oc_delete, self.ocp_client[0], 'secret', secret_name)
+        return secret_name
+
+    def create_storage_class(self, secret_name=None,
+                             sc_name_prefix="autotests-sc",
+                             create_vol_name_prefix=False,
+                             allow_volume_expansion=False,
+                             reclaim_policy="Delete",
+                             set_hacount=None,
+                             is_arbiter_vol=False, arbiter_avg_file_size=None):
+
+        # Create secret if one is not specified
+        if not secret_name:
+            secret_name = self.create_secret()
+
+        # Create storage class
+        secret_name_option = "secretname"
+        secret_namespace_option = "secretnamespace"
+        provisioner = self.sc.get("provisioner", "kubernetes.io/glusterfs")
+        if provisioner != "kubernetes.io/glusterfs":
+            secret_name_option = "rest%s" % secret_name_option
+            secret_namespace_option = "rest%s" % secret_namespace_option
+        parameters = {
+            "resturl": self.sc["resturl"],
+            "restuser": self.sc["restuser"],
+            secret_name_option: secret_name,
+            secret_namespace_option: self.sc.get(
+                "secretnamespace", self.sc.get("restsecretnamespace")),
+        }
+        if set_hacount:
+            parameters["hacount"] = self.sc.get("hacount", "3")
+        if is_arbiter_vol:
+            parameters["volumeoptions"] = "user.heketi.arbiter true"
+            if arbiter_avg_file_size:
+                parameters["volumeoptions"] += (
+                    ",user.heketi.average-file-size %s" % (
+                        arbiter_avg_file_size))
+        if create_vol_name_prefix:
+            parameters["volumenameprefix"] = self.sc.get(
+                "volumenameprefix", "autotest")
+        self.sc_name = oc_create_sc(
+            self.ocp_client[0],
+            sc_name_prefix=sc_name_prefix,
+            provisioner=provisioner,
+            allow_volume_expansion=allow_volume_expansion,
+            reclaim_policy=reclaim_policy,
+            **parameters)
+        self.addCleanup(oc_delete, self.ocp_client[0], "sc", self.sc_name)
+        return self.sc_name
+
+    def create_and_wait_for_pvcs(self, pvc_size=1,
+                                 pvc_name_prefix="autotests-pvc",
+                                 pvc_amount=1, sc_name=None):
+        node = self.ocp_client[0]
+
+        # Create storage class if not specified
+        if not sc_name:
+            if getattr(self, "sc_name", ""):
+                sc_name = self.sc_name
+            else:
+                sc_name = self.create_storage_class()
+
+        # Create PVCs
+        pvc_names = []
+        for i in range(pvc_amount):
+            pvc_name = oc_create_pvc(
+                node, sc_name, pvc_name_prefix=pvc_name_prefix,
+                pvc_size=pvc_size)
+            pvc_names.append(pvc_name)
+            self.addCleanup(
+                wait_for_resource_absence, node, 'pvc', pvc_name)
+
+        # Wait for PVCs to be in bound state
+        try:
+            for pvc_name in pvc_names:
+                verify_pvc_status_is_bound(node, pvc_name)
+        finally:
+            reclaim_policy = oc_get_custom_resource(
+                node, 'sc', ':.reclaimPolicy', sc_name)[0]
+
+            for pvc_name in pvc_names:
+                if reclaim_policy == 'Retain':
+                    pv_name = get_pv_name_from_pvc(node, pvc_name)
+                    self.addCleanup(oc_delete, node, 'pv', pv_name,
+                                    raise_on_absence=False)
+                    custom = (r':.metadata.annotations."gluster\.kubernetes'
+                              r'\.io\/heketi\-volume\-id"')
+                    vol_id = oc_get_custom_resource(
+                        node, 'pv', custom, pv_name)[0]
+                    if self.sc.get('provisioner') == "kubernetes.io/glusterfs":
+                        self.addCleanup(heketi_volume_delete,
+                                        self.heketi_client_node,
+                                        self.heketi_server_url, vol_id,
+                                        raise_on_error=False)
+                    else:
+                        self.addCleanup(heketi_blockvolume_delete,
+                                        self.heketi_client_node,
+                                        self.heketi_server_url, vol_id)
+                self.addCleanup(oc_delete, node, 'pvc', pvc_name,
+                                raise_on_absence=False)
+
+        return pvc_names
+
+    def create_and_wait_for_pvc(self, pvc_size=1,
+                                pvc_name_prefix='autotests-pvc', sc_name=None):
+        self.pvc_name = self.create_and_wait_for_pvcs(
+            pvc_size=pvc_size, pvc_name_prefix=pvc_name_prefix, sc_name=sc_name
+        )[0]
+        return self.pvc_name
+
+    def create_dc_with_pvc(self, pvc_name, timeout=300, wait_step=10):
+        dc_name = oc_create_app_dc_with_io(self.ocp_client[0], pvc_name)
+        self.addCleanup(oc_delete, self.ocp_client[0], 'dc', dc_name)
+        self.addCleanup(
+            scale_dc_pod_amount_and_wait, self.ocp_client[0], dc_name, 0)
+        pod_name = get_pod_name_from_dc(self.ocp_client[0], dc_name)
+        wait_for_pod_be_ready(self.ocp_client[0], pod_name,
+                              timeout=timeout, wait_step=wait_step)
+        return dc_name, pod_name
+
 
 class CnsSetupBaseClass(CnsBaseClass):
     '''
@@ -315,6 +462,9 @@ class CnsGlusterBlockBaseClass(CnsBaseClass):
          Glusterblock setup on CNS
         '''
         super(CnsGlusterBlockBaseClass, cls).setUpClass()
+        cls.sc = cls.cns_storage_class.get(
+            'storage_class2',
+            cls.cns_storage_class.get('block_storage_class'))
         for node in cls.ocp_all_nodes:
             if not edit_iptables_cns(node):
                 raise ExecutionError("failed to edit iptables")