Be able to only deploy capella cluster with terraform.py

Adds two flags that allow one to use the terraform.py script in order to
only deploy the capella cluster (serverless dataplane or provisioned
cluster), without deploying client/utility
nodes or serverless dbs.

This can be useful for debugging sometimes or doing some kind of manual
work on the cluster or dataplane, or if one sets up 2 Jenkins jobs: 1 to deploy a
cluster or dataplane and another to run a test on it (and then keep it around to
run more tests).

Change-Id: Ie517905a67e7f0d5c89e2ff6a12070b181f7ac30
Reviewed-on: https://review.couchbase.org/c/perfrunner/+/190191
Tested-by: Build Bot <[email protected]>
Reviewed-by: Laura Silaja <[email protected]>

Author: d-nagy

perfrunner/settings.py

@@ -7,10 +7,13 @@
 from typing import Dict, Iterable, Iterator, List, Tuple
 
 from decorator import decorator
-from fabric.api import local
 
 from logger import logger
-from perfrunner.helpers.misc import maybe_atoi, target_hash
+from perfrunner.helpers.misc import (
+    maybe_atoi,
+    run_local_shell_command,
+    target_hash,
+)
 
 CBMONITOR_HOST = 'cbmonitor.sc.couchbase.com'
 SHOWFAST_HOST = 'showfast.sc.couchbase.com'  # 'localhost:8000'
@@ -511,14 +514,13 @@ def server_group_map(self) -> dict:
         return server_grp_map
 
     def get_aws_iid(self, hostname: str, region: str) -> str:
-        iid = local(
+        iid, _, _ = run_local_shell_command(
             (
                 "env/bin/aws ec2 describe-instances --region {} "
                 "--filter \"Name=ip-address,Values=$(dig +short {})\" "
                 "--query \"Reservations[].Instances[].InstanceId\" "
                 "--output text"
-            ).format(region, hostname),
-            capture=True
+            ).format(region, hostname)
         )
         return iid.strip()
 
@@ -557,17 +559,13 @@ def set_nebula_instance_ids(self) -> None:
                 "--output text"
             ).format(region, self.infrastructure_settings['cbc_dataplane'])
 
-            dn_iids = local(
-                query.format('couchbase-cloud-nebula'),
-                capture=True
-            ).strip().split()
+            stdout, _, _ = run_local_shell_command(query.format('couchbase-cloud-nebula'))
+            dn_iids = stdout.strip().split()
             logger.info('Found DN instance IDs: {}'.format(', '.join(dn_iids)))
             self.config.set('nebula_instance_ids', 'direct_nebula', '\n' + '\n'.join(dn_iids))
 
-            dapi_iids = local(
-                query.format('couchbase-cloud-data-api'),
-                capture=True
-            ).strip().split()
+            stdout, _, _ = run_local_shell_command(query.format('couchbase-cloud-data-api'))
+            dapi_iids = stdout.strip().split()
             logger.info('Found DAPI instance IDs: {}'.format(', '.join(dapi_iids)))
             self.config.set('nebula_instance_ids', 'dapi', '\n' + '\n'.join(dapi_iids))
 
@@ -579,16 +577,16 @@ def set_sgw_instance_ids(self) -> None:
 
         if self.capella_backend == 'aws':
             region = os.environ.get('AWS_REGION', 'us-east-1')
-            sgids = local(
+            stdout, _, _ = run_local_shell_command(
                 (
                     "env/bin/aws ec2 describe-instances --region {} "
                     "--filters \"Name=tag-key,Values=couchbase-cloud-syncgateway-id\" "
                     "\"Name=tag:couchbase-app-services,Values={}\" "
                     "--query \"Reservations[].Instances[].InstanceId\" "
                     "--output text"
                 ).format(region, self.infrastructure_settings['cbc_cluster']),
-                capture=True
-            ).strip().split()
+            )
+            sgids = stdout.strip().split()
             logger.info("Found Instance IDs for sgw: {}".format(', '.join(sgids)))
             self.config.set('sgw_instance_ids', 'sync_gateways', '\n', + '\n'.join(sgids))
             self.update_spec_file()

perfrunner/utils/terraform.py

@@ -219,6 +219,7 @@ def create_tfvar_nodes(self) -> Dict[str, Dict]:
         return tfvar_nodes
 
     def populate_tfvars(self):
+        logger.info('Setting tfvars')
         cloud_provider = self.backend if self.provider == 'capella' else self.provider
         global_tag = self.options.tag if self.options.tag else ''
         if cloud_provider.lower() == 'gcp':
@@ -254,10 +255,13 @@ def populate_tfvars(self):
 
     # Initializes terraform environment.
     def terraform_init(self, provider):
+        logger.info('Initializating Terraform (terraform init)')
         local('cd terraform/{} && terraform init >> terraform.log'.format(provider))
 
     # Apply and output terraform deployment.
     def terraform_apply(self, provider):
+        logger.info('Building and executing Terraform deployment plan '
+                    '(terraform plan, terraform apply)')
         local('cd terraform/{} && '
               'terraform plan -out tfplan.out >> terraform.log && '
               'terraform apply -auto-approve tfplan.out'
@@ -270,6 +274,8 @@ def terraform_output(self, provider):
         return output
 
     def terraform_destroy(self, provider):
+        logger.info('Building and executing Terraform destruction plan '
+                    '(terraform plan -destroy, terraform apply)')
         local('cd terraform/{} && '
               'terraform plan -destroy -out tfplan_destroy.out >> terraform.log && '
               'terraform apply -auto-approve tfplan_destroy.out'
@@ -461,14 +467,15 @@ def deploy(self):
         if not self.project_id:
             self.create_project()
 
-        # Configure terraform
-        self.populate_tfvars()
-        self.terraform_init(self.backend)
+        if not self.options.capella_only:
+            # Configure terraform
+            self.populate_tfvars()
+            self.terraform_init(self.backend)
 
-        # Deploy non-capella resources
-        self.terraform_apply(self.backend)
-        non_capella_output = self.terraform_output(self.backend)
-        Terraform.update_spec(self, non_capella_output)
+            # Deploy non-capella resources
+            self.terraform_apply(self.backend)
+            non_capella_output = self.terraform_output(self.backend)
+            Terraform.update_spec(self, non_capella_output)
 
         # Deploy capella cluster
         self.deploy_cluster()
@@ -479,8 +486,8 @@ def deploy(self):
         # Update cluster spec file
         self.update_spec()
 
-        # Do VPC peering
-        if self.options.vpc_peering:
+        if not self.options.capella_only and self.options.vpc_peering:
+            # Do VPC peering
             network_info = non_capella_output['network']['value']
             self.peer_vpc(network_info, self.cluster_ids[0])
 
@@ -1042,19 +1049,28 @@ def get_tenant_id(self):
         return tenant_id
 
     def deploy(self):
-        # Configure terraform
-        Terraform.populate_tfvars(self)
-        self.terraform_init(self.backend)
-
-        # Deploy non-capella resources
-        self.terraform_apply(self.backend)
-        non_capella_output = self.terraform_output(self.backend)
-        Terraform.update_spec(self, non_capella_output)
+        if not self.options.capella_only:
+            logger.info('Deploying non-Capella resources')
+            # Configure terraform
+            Terraform.populate_tfvars(self)
+            self.terraform_init(self.backend)
+
+            # Deploy non-capella resources
+            self.terraform_apply(self.backend)
+            non_capella_output = self.terraform_output(self.backend)
+            Terraform.update_spec(self, non_capella_output)
+        else:
+            logger.info('Skipping deploying non-Capella resources as --capella-only flag is set')
 
         # Deploy serverless dataplane + databases
         self.deploy_serverless_dataplane()
-        self.create_project()
-        self.create_serverless_dbs()
+
+        if not self.options.no_serverless_dbs:
+            self.create_project()
+            self.create_serverless_dbs()
+        else:
+            logger.info('Skipping deploying serverless dbs as --no-serverless-dbs flag is set')
+
         self.update_spec()
 
     def destroy(self):
@@ -1078,6 +1094,7 @@ def destroy(self):
 
     def deploy_serverless_dataplane(self):
         if not self.dp_id:
+            logger.info('Deploying serverless dataplane')
             # If no dataplane ID given (which is normal) then we deploy a new one
             nebula_config = self.infra_spec.direct_nebula
             dapi_config = self.infra_spec.data_api
@@ -1134,7 +1151,8 @@ def deploy_serverless_dataplane(self):
             self.infra_spec.config.set('infrastructure', 'cbc_dataplane', self.dp_id)
             self.infra_spec.update_spec_file()
         else:
-            logger.info('Existing dataplane specified: {}'.format(self.dp_id))
+            logger.info('Skipping serverless dataplane deployment as existing dataplane specified: '
+                        '{}'.format(self.dp_id))
             logger.info('Verifying existing dataplane deployment')
 
         # Whether we have just deployed a dataplane or not, we will confirm the deployment
@@ -1273,18 +1291,15 @@ def create_serverless_dbs(self):
             logger.info('All serverless DBs deployed')
 
     def update_spec(self):
-        db_id = self.test_config.buckets[0]
-        resp = self.serverless_client.get_database_debug_info(db_id)
+        resp = self.serverless_client.get_serverless_dataplane_info(self.dp_id)
         raise_for_status(resp)
         dp_info = resp.json()
 
-        logger.info('Dataplane config: {}'.format(pretty_dict(dp_info['dataplane'])))
-
         resp = self.serverless_client.get_access_to_serverless_dataplane_nodes(self.dp_id)
         raise_for_status(resp)
         dp_creds = resp.json()
 
-        hostname = dp_info['dataplane']['couchbase']['nodes'][0]['hostname']
+        hostname = dp_info['couchbase']['nodes'][0]['hostname']
         auth = (
             dp_creds['couchbaseCreds']['username'],
             dp_creds['couchbaseCreds']['password']
@@ -1737,7 +1752,7 @@ def get_args():
                         choices=[
                            'us-central1-a',
                            'us-central1-b',
-                           'us-central1-c'
+                           'us-central1-c',
                            'us-central1-f',
                            'us-west1-a',
                            'us-west1-b',
@@ -1811,6 +1826,13 @@ def get_args():
                         action='store_true',
                         help='Don\'t destroy cluster or serverless dataplane, only the clients '
                              'and utilities')
+    parser.add_argument('--no-serverless-dbs',
+                        action='store_true',
+                        help='Don\'t deploy serverless databases, only deploy serverless dataplane')
+    parser.add_argument('--capella-only',
+                        action='store_true',
+                        help='Only deploy Capella resources (provisioned cluster or serverless '
+                             'dataplane). Will not deploy perf client or utility nodes.')
     parser.add_argument('-t', '--tag',
                         help='Global tag for launched instances.')
     parser.add_argument('--enable-disk-autoscaling',