Add ovdc, system, template request handlers (vmware#388)

* Add ovdc, template, and system request handlers
* ovdc_request_handler.py became ovdc_handler.py
* Removed unnecessary classes (ServiceProcessor, OvdcManager)
* Moved all generic OVDC code to ovdc_utils.py
* ovdc_handler.py is responsible for using the request dict and auth
  token to pass relevant data to the generic ovdc functions. It is
  also responsible for validating request dict keys relevant to
  the operation

container_service_extension/broker_manager.py

@@ -5,13 +5,12 @@
 from container_service_extension.exceptions import ClusterAlreadyExistsError
 from container_service_extension.exceptions import ClusterNotFoundError
 from container_service_extension.exceptions import CseServerError
-from container_service_extension.ovdc_manager import \
-    construct_ctr_prov_ctx_from_ovdc_metadata
+import container_service_extension.ovdc_utils as ovdc_utils
 from container_service_extension.pksbroker import PKSBroker
 from container_service_extension.pksbroker_manager import PksBrokerManager
 from container_service_extension.server_constants import CseOperation
 from container_service_extension.server_constants import K8S_PROVIDER_KEY
-from container_service_extension.server_constants import K8sProviders
+from container_service_extension.server_constants import K8sProvider
 from container_service_extension.server_constants import PKS_CLUSTER_DOMAIN_KEY
 from container_service_extension.server_constants import PKS_PLANS_KEY
 from container_service_extension.shared_constants import RequestKey
@@ -31,7 +30,7 @@
 #  3. Refactor both client and server code accordingly
 #  4. As part of refactoring, avoid accessing HTTP request body directly
 #  from VcdBroker and PksBroker. We should try to limit processing request to
-#  processor.py and broker_manager.py.
+#  request_processor.py and broker_manager.py.
 
 
 class BrokerManager(object):
@@ -150,18 +149,16 @@ def _create_cluster(self, **cluster_spec):
         # logged-in user to check for duplicates.
         cluster, _ = self._find_cluster_in_org(cluster_name,
                                                is_org_admin_search=True)
-        if not cluster:
-            ctr_prov_ctx = construct_ctr_prov_ctx_from_ovdc_metadata(
-                ovdc_name=vdc_name, org_name=org_name)
-            if ctr_prov_ctx.get(K8S_PROVIDER_KEY) == K8sProviders.PKS:
-                cluster_spec['pks_plan'] = ctr_prov_ctx[PKS_PLANS_KEY][0]
-                cluster_spec['pks_ext_host'] = \
-                    f"{cluster_name}.{ctr_prov_ctx[PKS_CLUSTER_DOMAIN_KEY]}"
-            broker = self._get_broker_based_on_ctr_prov_ctx(ctr_prov_ctx)
-            return broker.create_cluster(**cluster_spec)
-        else:
-            raise ClusterAlreadyExistsError(
-                f"Cluster {cluster_name} already exists.")
+        if cluster:
+            raise ClusterAlreadyExistsError(f"Cluster {cluster_name} "
+                                            f"already exists.")
+
+        ctr_prov_ctx = ovdc_utils.get_ovdc_k8s_provider_metadata(org_name=org_name, ovdc_name=vdc_name, include_credentials=True, include_nsxt_info=True) # noqa: E501
+        if ctr_prov_ctx.get(K8S_PROVIDER_KEY) == K8sProvider.PKS:
+            cluster_spec['pks_plan'] = ctr_prov_ctx[PKS_PLANS_KEY][0]
+            cluster_spec['pks_ext_host'] = f"{cluster_name}.{ctr_prov_ctx[PKS_CLUSTER_DOMAIN_KEY]}" # noqa: E501
+        broker = self._get_broker_based_on_ctr_prov_ctx(ctr_prov_ctx)
+        return broker.create_cluster(**cluster_spec)
 
     def _delete_cluster(self, **cluster_spec):
         cluster, broker = self._get_cluster_info(**cluster_spec)
@@ -173,7 +170,7 @@ def _get_cluster_info(self, **cluster_spec):
         Logic of the method is as follows.
 
         If 'ovdc' is present in the cluster spec,
-            choose the right broker (by identifying the container_provider
+            choose the right broker (by identifying the k8s provider
             (vcd|pks) defined for that ovdc) to do get_cluster operation.
         else
             Invoke set of all (vCD/PKS) brokers in the org to find the cluster
@@ -199,7 +196,7 @@ def _list_clusters(self):
         """Logic of the method is as follows.
 
         If 'ovdc' is present in the body,
-            choose the right broker (by identifying the container_provider
+            choose the right broker (by identifying the k8s provider
             (vcd|pks) defined for that ovdc) to do list_clusters operation.
         Else
             Invoke set of all (vCD/PKS)brokers in the org to do list_clusters.
@@ -245,10 +242,10 @@ def _get_broker_based_on_ctr_prov_ctx(self, ctr_prov_ctx):
         # exception.
         if is_pks_enabled():
             if ctr_prov_ctx:
-                if ctr_prov_ctx.get(K8S_PROVIDER_KEY) == K8sProviders.PKS:
+                if ctr_prov_ctx.get(K8S_PROVIDER_KEY) == K8sProvider.PKS:
                     return PKSBroker(self.tenant_auth_token, self.req_spec,
                                      pks_ctx=ctr_prov_ctx)
-                elif ctr_prov_ctx.get(K8S_PROVIDER_KEY) == K8sProviders.NATIVE:
+                elif ctr_prov_ctx.get(K8S_PROVIDER_KEY) == K8sProvider.NATIVE:
                     return VcdBroker(self.tenant_auth_token, self.req_spec)
 
         else:
@@ -258,7 +255,7 @@ def _get_broker_based_on_ctr_prov_ctx(self, ctr_prov_ctx):
                              "deployment")
 
     def _get_broker_based_on_vdc(self):
-        """Get the broker based on ovdc.
+        """Get the broker based on org VDC.
 
         :return: broker
 
@@ -267,7 +264,6 @@ def _get_broker_based_on_vdc(self):
         ovdc_name = self.req_spec.get(RequestKey.OVDC_NAME)
         org_name = self.req_spec.get(RequestKey.ORG_NAME)
 
-        ctr_prov_ctx = construct_ctr_prov_ctx_from_ovdc_metadata(
-            ovdc_name=ovdc_name, org_name=org_name)
+        ctr_prov_ctx = ovdc_utils.get_ovdc_k8s_provider_metadata(org_name=org_name, ovdc_name=ovdc_name, include_credentials=True, include_nsxt_info=True) # noqa: E501
 
         return self._get_broker_based_on_ctr_prov_ctx(ctr_prov_ctx)

container_service_extension/client/cse.py

@@ -15,7 +15,7 @@
 from container_service_extension.client.system import System
 from container_service_extension.exceptions import CseClientError
 from container_service_extension.server_constants import K8S_PROVIDER_KEY
-from container_service_extension.server_constants import K8sProviders
+from container_service_extension.server_constants import K8sProvider
 from container_service_extension.service import Service
 from container_service_extension.shared_constants import ServerAction
 
@@ -733,7 +733,7 @@ def list_nodes(ctx, name, org, vdc):
             org = ctx.obj['profiles'].get('org_in_use')
         cluster = Cluster(client)
         cluster_info = cluster.get_cluster_info(name, org=org, vdc=vdc)
-        if cluster_info.get(K8S_PROVIDER_KEY) != K8sProviders.NATIVE:
+        if cluster_info.get(K8S_PROVIDER_KEY) != K8sProvider.NATIVE:
             raise CseClientError('Node commands are not supported by non '
                                  'native clusters.')
         all_nodes = cluster_info['master_nodes'] + cluster_info['nodes']
@@ -941,9 +941,9 @@ def list_ovdcs(ctx, list_pks_plans):
 @click.option(
     '-k',
     '--k8s-provider',
-    'container_provider',
+    'k8s_provider',
     required=True,
-    type=click.Choice([K8sProviders.NATIVE, K8sProviders.PKS]),
+    type=click.Choice([K8sProvider.NATIVE, K8sProvider.PKS]),
     help="Name of the Kubernetes provider to use for this org VDC")
 @click.option(
     '-p',
@@ -952,15 +952,15 @@ def list_ovdcs(ctx, list_pks_plans):
     required=False,
     metavar='PLAN_NAME',
     help=f"PKS plan to use for all cluster deployments in this org VDC "
-         f"(Exclusive to --k8s-provider={K8sProviders.PKS}) (Required)")
+         f"(Exclusive to --k8s-provider={K8sProvider.PKS}) (Required)")
 @click.option(
     '-d',
     '--pks-cluster-domain',
     'pks_cluster_domain',
     required=False,
     help=f"Domain name suffix used to construct FQDN of deployed clusters "
          f"in this org VDC "
-         f"(Exclusive to --k8s-provider={K8sProviders.PKS}) (Required)")
+         f"(Exclusive to --k8s-provider={K8sProvider.PKS}) (Required)")
 @click.option(
     '-o',
     '--org',
@@ -970,10 +970,10 @@ def list_ovdcs(ctx, list_pks_plans):
     metavar='ORG_NAME',
     help="Use the specified org to look for the org VDC. Defaults to current "
          "org in use")
-def ovdc_enable(ctx, ovdc_name, container_provider, pks_plan,
+def ovdc_enable(ctx, ovdc_name, k8s_provider, pks_plan,
                 pks_cluster_domain, org_name):
     """Set Kubernetes provider for an org VDC."""
-    if container_provider == K8sProviders.PKS and \
+    if k8s_provider == K8sProvider.PKS and \
             (pks_plan is None or pks_cluster_domain is None):
         click.secho("One or both of the required params (--pks-plan,"
                     " --pks-cluster-domain) are missing", fg='yellow')
@@ -990,7 +990,7 @@ def ovdc_enable(ctx, ovdc_name, container_provider, pks_plan,
                 enable=True,
                 ovdc_name=ovdc_name,
                 org_name=org_name,
-                container_provider=container_provider,
+                k8s_provider=k8s_provider,
                 pks_plan=pks_plan,
                 pks_cluster_domain=pks_cluster_domain)
             stdout(result, ctx)
@@ -1023,8 +1023,9 @@ def ovdc_disable(ctx, ovdc_name, org_name):
             ovdc = Ovdc(client)
             if org_name is None:
                 org_name = ctx.obj['profiles'].get('org_in_use')
-            result = ovdc.update_ovdc_for_k8s(
-                enable=False, ovdc_name=ovdc_name, org_name=org_name)
+            result = ovdc.update_ovdc_for_k8s(enable=False,
+                                              ovdc_name=ovdc_name,
+                                              org_name=org_name)
             stdout(result, ctx)
         else:
             stderr("Insufficient permission to perform operation.", ctx)

container_service_extension/client/ovdc.py

@@ -7,7 +7,7 @@
 from container_service_extension.client.response_processor import \
     process_response
 from container_service_extension.pyvcloud_utils import get_vdc
-from container_service_extension.server_constants import K8sProviders
+from container_service_extension.server_constants import K8sProvider
 from container_service_extension.shared_constants import RequestKey
 from container_service_extension.shared_constants import RequestMethod
 
@@ -32,13 +32,13 @@ def update_ovdc_for_k8s(self,
                             enable,
                             ovdc_name,
                             org_name=None,
-                            container_provider=None,
+                            k8s_provider=None,
                             pks_plan=None,
                             pks_cluster_domain=None):
         """Enable/Disable ovdc for k8s for the given container provider.
 
         :param bool enable: If set to True will enable the vdc for the
-            paricular container_provider else if set to False, K8 support on
+            paricular k8s_provider else if set to False, K8 support on
             the vdc will be disabled.
         :param str ovdc_name: Name of the ovdc to be enabled
         :param str k8s_provider: Name of the container provider
@@ -58,15 +58,15 @@ def update_ovdc_for_k8s(self,
         uri = f'{self._uri}/ovdc/{ovdc_id}'
 
         if not enable:
-            container_provider = K8sProviders.NONE
+            k8s_provider = K8sProvider.NONE
             pks_plan = None
             pks_cluster_domain = None
 
         data = {
             RequestKey.OVDC_ID: ovdc_id,
             RequestKey.OVDC_NAME: ovdc_name,
             RequestKey.ORG_NAME: org_name,
-            RequestKey.K8S_PROVIDER: container_provider,
+            RequestKey.K8S_PROVIDER: k8s_provider,
             RequestKey.PKS_PLAN_NAME: pks_plan,
             RequestKey.PKS_CLUSTER_DOMAIN: pks_cluster_domain,
         }

container_service_extension/consumer.py

@@ -12,7 +12,7 @@
 import requests
 
 from container_service_extension.logger import SERVER_LOGGER as LOGGER
-from container_service_extension.processor import ServiceProcessor
+import container_service_extension.request_processor as request_processor
 from container_service_extension.server_constants import EXCHANGE_TYPE
 
 
@@ -39,7 +39,6 @@ def __init__(self,
         self.exchange = exchange
         self.routing_key = routing_key
         self.queue = routing_key
-        self.service_processor = ServiceProcessor()
         self.fsencoding = sys.getfilesystemencoding()
 
     def connect(self):
@@ -153,7 +152,7 @@ def on_message(self, unused_channel, basic_deliver, properties, body):
                          f"from {properties.app_id} "
                          f"({threading.currentThread().ident}): "
                          f"{json.dumps(body_json)}, props: {properties}")
-            result = self.service_processor.process_request(body_json)
+            result = request_processor.process_request(body_json)
             status_code = result['status_code']
             reply_body = json.dumps(result['body'])
         except Exception as e: