Add ovdc, system, template request handlers

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: