sbcli-pre 1.2.4__zip → 1.2.5__zip

sbcli_pre-1.2.5/simplyblock_web/blueprints/web_api_deployer.py

@@ -0,0 +1,394 @@
+#!/usr/bin/env python
+# encoding: utf-8
+import logging
+import boto3
+import time
+from botocore.exceptions import ClientError
+import threading
+import uuid
+
+from flask import Blueprint
+from flask import request
+
+from simplyblock_web import utils
+
+from simplyblock_core import kv_store
+from simplyblock_core.models.deployer import Deployer
+
+logger = logging.getLogger(__name__)
+logger.setLevel(logging.DEBUG)
+bp = Blueprint("deployer", __name__)
+db_controller = kv_store.DBController()
+
+
+## Terraform variables
+document_name = 'AWS-RunShellScript'
+output_key_prefix = 'ssm-output'
+
+# intialise clients
+ssm = boto3.client('ssm', region_name='us-east-1')
+s3 = boto3.client('s3', region_name='us-east-1')
+
+
+def get_instance_tf_engine_instance_id():
+    tag_value = 'tfengine'
+    tag_key = 'Name'
+
+    ec2 = boto3.client('ec2', region_name='us-east-1')
+    response = ec2.describe_instances(
+        Filters=[
+            {
+                'Name': f'tag:{tag_key}',
+                'Values': [tag_value]
+            },
+            {
+                'Name': 'instance-state-name',
+                'Values': ['running']
+            }
+        ]
+    )
+
+    # Extract instance IDs
+    instance_ids = [
+        instance['InstanceId']
+        for reservation in response['Reservations']
+        for instance in reservation['Instances']
+    ]
+    return instance_ids
+
+def check_command_status(ssm_client, command_id, instance_id):
+    # time.sleep(1) # wait for a second to avoid: An error occurred (InvocationDoesNotExist)
+    try:
+        response = ssm_client.get_command_invocation(
+            CommandId=command_id,
+            InstanceId=instance_id
+        )
+        return response['Status']
+    except Exception as e:
+        print(f"Exeception {e}")
+        return "Exeception"
+
+
+def wait_for_s3_object(s3_client, bucket, key, timeout=300, interval=5):
+    elapsed_time = 0
+
+    while elapsed_time < timeout:
+        try:
+            s3_client.head_object(Bucket=bucket, Key=key)
+            return True
+        except ClientError as e:
+            if e.response['Error']['Code'] == '404':
+                time.sleep(interval)
+                elapsed_time += interval
+            else:
+                raise e
+    return False
+
+# todo: fetch both STDOUT and STDERR based on
+def display_logs(command_id, instance_id, status, tf_logs_bucket_name):
+    output_s3_key = f'{output_key_prefix}/{command_id}/{instance_id}/awsrunShellScript/0.awsrunShellScript/stdout'
+    error_s3_key = f'{output_key_prefix}/{command_id}/{instance_id}/awsrunShellScript/0.awsrunShellScript/stderr'
+
+    stdout_content = ''
+    stderr_content = ''
+    # if success get STDOUT. else get STDERR
+    if status == 'Success':
+        wait_for_s3_object(s3, tf_logs_bucket_name, output_s3_key)
+        try:
+            stdout_object = s3.get_object(Bucket=tf_logs_bucket_name, Key=output_s3_key)
+            stdout_content = stdout_object['Body'].read().decode('utf-8')
+            print('Output:')
+            print(stdout_content)
+        except ClientError as ex:
+            if ex.response['Error']['Code'] == 'NoSuchKey':
+                print('No object found - returning empty')
+    else:
+        wait_for_s3_object(s3, tf_logs_bucket_name, error_s3_key)
+        try:
+            stderr_object = s3.get_object(Bucket=tf_logs_bucket_name, Key=error_s3_key)
+            stderr_content = stderr_object['Body'].read().decode('utf-8')
+            print('Error:')
+            print(stderr_content)
+        except ClientError as ex:
+            if ex.response['Error']['Code'] == 'NoSuchKey':
+                print('No object found - returning empty')
+
+    return stdout_content, stderr_content
+
+def wait_for_status(command_id, instance_id):
+    status = 'Pending'
+    while status not in ['Success', 'Failed', 'Cancelled', 'TimedOut']:
+        status = check_command_status(ssm, command_id, instance_id)
+        print(f'Current status: {status}')
+        if status in ['Success', 'Failed', 'Cancelled', 'TimedOut']:
+            break
+        time.sleep(5)  # Wait for 5 seconds before checking the status again
+
+    return status
+
+def update_cluster(d, kv_store, storage_nodes, availability_zone):
+
+    print('started update_cluster')
+    TFSTATE_BUCKET=d.tf_state_bucket_name
+    TFSTATE_KEY='csi'
+    TFSTATE_REGION=d.tf_state_bucket_region
+    TF_WORKSPACE=d.tf_workspace
+
+    mgmt_nodes = d.mgmt_nodes
+    aws_region = d.region
+    ECR_REGION = d.ecr_region
+    ECR_REPOSITORY_NAME = d.ecr_repository_name
+    ECR_IMAGE_TAG = d.ecr_image_tag
+    ECR_ACCOUNT_ID = d.ecr_account_id
+    tf_logs_bucket_name = d.tf_logs_bucket_name
+
+    d.status = "in_progress"
+    d.write_to_db(kv_store)
+
+    instance_ids = get_instance_tf_engine_instance_id()
+    if len(instance_ids) == 0:
+        # wait for a min and try again before returning error on the API
+        print('no instance IDs')
+        d.status = "no instance IDs"
+        d.write_to_db(kv_store)
+        return False, "", "no instance IDs"
+
+    commands = [
+        f"""
+        docker pull $ECR_ACCOUNT_ID.dkr.ecr.{ECR_REGION}.amazonaws.com/{ECR_REPOSITORY_NAME}:{ECR_IMAGE_TAG}
+        docker volume create terraform
+        """,
+        f"""
+        docker run --rm -v terraform:/app -e TF_LOG=DEBUG -w /app {ECR_ACCOUNT_ID}.dkr.ecr.{ECR_REGION}.amazonaws.com/{ECR_REPOSITORY_NAME}:{ECR_IMAGE_TAG} \
+            workspace select -or-create {TF_WORKSPACE}
+        """,
+        f"""
+        docker run --rm -v terraform:/app -w /app {ECR_ACCOUNT_ID}.dkr.ecr.{ECR_REGION}.amazonaws.com/{ECR_REPOSITORY_NAME}:{ECR_IMAGE_TAG} \
+            init -reconfigure -input=false \
+                    -backend-config='bucket={TFSTATE_BUCKET}' \
+                    -backend-config='key={TFSTATE_KEY}' \
+                    -backend-config='region={TFSTATE_REGION}'
+        """,
+        f"""
+        docker run --rm -v terraform:/app -w /app {ECR_ACCOUNT_ID}.dkr.ecr.{ECR_REGION}.amazonaws.com/{ECR_REPOSITORY_NAME}:{ECR_IMAGE_TAG} \
+            plan -var mgmt_nodes={mgmt_nodes} -var storage_nodes={storage_nodes} -var az={availability_zone} -var region={aws_region}
+        """,
+        f"""
+        docker run --rm -v terraform:/app -w /app {ECR_ACCOUNT_ID}.dkr.ecr.{ECR_REGION}.amazonaws.com/{ECR_REPOSITORY_NAME}:{ECR_IMAGE_TAG} \
+         apply -var mgmt_nodes={mgmt_nodes} -var storage_nodes={storage_nodes} -var az={availability_zone} -var region={aws_region} --auto-approve
+        """
+    ]
+
+    # Send command with S3 output parameters
+    response = ssm.send_command(
+        InstanceIds=instance_ids,
+        DocumentName=document_name,
+        Parameters={
+            'commands': commands
+        },
+        OutputS3BucketName=tf_logs_bucket_name,
+        OutputS3KeyPrefix=output_key_prefix
+    )
+
+    command_id = response['Command']['CommandId']
+    print(f'Command ID: {command_id}')
+    d.status = f"waiting for status. commandID: {command_id}"
+    d.write_to_db(kv_store)
+
+    d.status = wait_for_status(command_id, instance_ids[0])
+    d.write_to_db(kv_store)
+
+    if d.status == "Success":
+        # get terraform outputs
+        commands = [
+        f"""
+        docker run --rm -v terraform:/app -w /app {ECR_ACCOUNT_ID}.dkr.ecr.{ECR_REGION}.amazonaws.com/{ECR_REPOSITORY_NAME}:{ECR_IMAGE_TAG} \
+         output --json
+        """
+        ]
+        response = ssm.send_command(
+            InstanceIds=instance_ids,
+            DocumentName=document_name,
+            Parameters={
+                'commands': commands
+            },
+            OutputS3BucketName=tf_logs_bucket_name,
+            OutputS3KeyPrefix=output_key_prefix
+        )
+
+        command_id = response['Command']['CommandId']
+        print(f'Command ID: {command_id}')
+        d.status = "fetching tfouputs"
+        d.write_to_db(kv_store)
+
+        d.status = wait_for_status(command_id, instance_ids[0])
+        d.write_to_db(kv_store)
+
+        stdout, _ = display_logs(command_id, instance_ids[0], d.status, tf_logs_bucket_name)
+        d.tf_output = stdout
+        d.storage_nodes = storage_nodes
+        d.availability_zone = availability_zone
+        d.write_to_db(kv_store)
+
+
+@bp.route('/deployer', methods=['GET'], defaults={'uuid': None})
+@bp.route('/deployer/<string:uuid>', methods=['GET'])
+def list_deployer(uuid):
+    deployers_list = []
+    if uuid:
+        dpl = db_controller.get_deployer_by_id(uuid)
+        if dpl:
+            deployers_list.append(dpl)
+        else:
+            return utils.get_response_error(f"Deployer not found: {uuid}", 404)
+    else:
+        dpls = db_controller.get_deployers()
+        if dpls:
+            deployers_list.extend(dpls)
+
+    data = []
+    for deployer in deployers_list:
+        d = deployer.get_clean_dict()
+        data.append(d)
+    return utils.get_response(data)
+
+def validate_tf_settings(dpl_data):
+    """
+    """
+    if 'tf_state_bucket_name' not in dpl_data:
+        return "missing required param: tf_state_bucket_name"
+    if 'tf_state_bucket_region' not in dpl_data:
+        return "missing required param: tf_state_bucket_region"
+    if 'tf_workspace' not in dpl_data:
+        return "missing required param: tf_workspace"
+    if 'tf_logs_bucket_name' not in dpl_data:
+        return "missing required param: tf_logs_bucket_name"
+    if 'ecr_account_id' not in dpl_data:
+        return "missing required param: ecr_account_id"
+    if 'ecr_region' not in dpl_data:
+        return "missing required param: ecr_region"
+    if 'ecr_repository_name' not in dpl_data:
+        return "missing required param: ecr_repository_name"
+    if 'ecr_image_tag' not in dpl_data:
+        return "missing required param: ecr_image_tag"
+
+    return ""
+
+def validate_tf_vars(dpl_data):
+    """
+    """
+    if 'region' not in dpl_data:
+        return "missing required param: region"
+    if 'availability_zone' not in dpl_data:
+        return "missing required param: availability_zone"
+    if 'sbcli_cmd' not in dpl_data:
+        return "missing required param: sbcli_cmd"
+    if 'sbcli_pkg_version' not in dpl_data:
+        return "missing required param: sbcli_pkg_version"
+    if 'mgmt_nodes' not in dpl_data:
+        return "missing required param: mgmt_nodes"
+    if 'storage_nodes' not in dpl_data:
+        return "missing required param: storage_nodes"
+    if 'mgmt_nodes_instance_type' not in dpl_data:
+        return "missing required param: mgmt_nodes_instance_type"
+    if 'storage_nodes_instance_type' not in dpl_data:
+        return "missing required param: storage_nodes_instance_type"
+
+    return ""
+
+@bp.route('/deployer/tfvars', methods=['POST'])
+def set_tf_vars():
+    """
+    Take the terraform variables and replace the existing values
+    Used to set the TF vars that are used currently
+    Ideally this should be called immediately the first cluster is created. So that for all the subsequent
+    storage node add in a different availability zone can be done using the /deployer API
+    """
+    dpl_data = request.get_json()
+    validation_err = validate_tf_vars(dpl_data)
+    if validation_err != "":
+        return utils.get_response_error(validation_err, 400)
+
+    validation_err = validate_tf_settings(dpl_data)
+    if validation_err != "":
+        return utils.get_response_error(validation_err, 400)
+
+    # if there are no deployments, create a new one.
+    # else update the existing one
+    d = get_deployer()
+    if d is None:
+        d = Deployer()
+        d.uuid = str(uuid.uuid4())
+
+    # set TF variables
+    d.region = dpl_data['region']
+    d.availability_zone = dpl_data['availability_zone']
+    d.sbcli_cmd = dpl_data['sbcli_cmd']
+    d.sbcli_pkg_version = dpl_data['sbcli_pkg_version']
+    d.mgmt_nodes = dpl_data['mgmt_nodes']
+    d.storage_nodes = dpl_data['storage_nodes']
+    d.mgmt_nodes_instance_type = dpl_data['mgmt_nodes_instance_type']
+    d.storage_nodes_instance_type = dpl_data['storage_nodes_instance_type']
+
+    # set TF settings
+    d.tf_state_bucket_name = dpl_data['tf_state_bucket_name']
+    d.tf_state_bucket_region = dpl_data['tf_state_bucket_region']
+    d.tf_workspace = dpl_data['tf_workspace']
+    d.tf_logs_bucket_name = dpl_data['tf_logs_bucket_name']
+    d.ecr_account_id = dpl_data['ecr_account_id']
+    d.ecr_region = dpl_data['ecr_region']
+    d.ecr_repository_name = dpl_data['ecr_repository_name']
+    d.ecr_image_tag = dpl_data['ecr_image_tag']
+
+    d.write_to_db(db_controller.kv_store)
+    return utils.get_response(d.to_dict()), 201
+
+@bp.route('/deployer', methods=['POST'])
+def add_deployer():
+    """
+    This API creates the Infrastructure in a different AZ and on the same existing AWS Account
+    """
+
+    # validations
+    dpl_data = request.get_json()
+
+    if "uuid" not in dpl_data:
+        return utils.get_response_error("missing required param: uuid", 400)
+
+    uuid = dpl_data['uuid']
+    d = db_controller.get_deployer_by_id(uuid)
+
+    if "storage_nodes" not in dpl_data:
+        return utils.get_response_error("missing required param: storage_nodes", 400)
+
+    if "availability_zone" not in dpl_data:
+        return utils.get_response_error("missing required param: availability_zone", 400)
+
+    # start the deployment
+    d.status = "started"
+    d.write_to_db(db_controller.kv_store)
+
+    storage_nodes = int(dpl_data['storage_nodes'])
+    availability_zone = dpl_data['availability_zone']
+    d.write_to_db(db_controller.kv_store)
+
+    t = threading.Thread(
+        target=update_cluster,
+        args=(d, db_controller.kv_store, d.storage_nodes+storage_nodes, availability_zone))
+
+    t.start()
+
+    output = {
+        "status": d.status,
+    }
+
+    return utils.get_response(output, http_code=201)
+
+def get_deployer():
+    """
+    get the deployer if it exists. Else returns an None
+    """
+    dpls = db_controller.get_deployers()
+    if len(dpls) > 0:
+        return dpls[0]
+    return None

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_web/blueprints/web_api_device.py

@@ -3,7 +3,7 @@
 
 import logging
 
-from flask import Blueprint, request
+from flask import Blueprint
 
 from simplyblock_core.controllers import device_controller
 from simplyblock_web import utils
@@ -33,15 +33,12 @@ def list_devices_by_node(uuid):
 def list_storage_devices(uuid):
     devices = []
     if uuid:
-        dev = db_controller.get_storage_device_by_id(uuid)
+        dev = db_controller.get_storage_devices(uuid)
         if not dev:
             return utils.get_response_error(f"device not found: {uuid}", 404)
         devices = [dev]
     else:
-        cluster_id = utils.get_cluster_id(request)
-        nodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
-        for node in nodes:
-            devices.append(node.nvme_devices)
+        devices = db_controller.get_storage_devices()
     data = []
     for dev in devices:
         data.append(dev.get_clean_dict())
@@ -50,7 +47,7 @@ def list_storage_devices(uuid):
 @bp.route('/device/capacity/<string:uuid>/history/<string:history>', methods=['GET'])
 @bp.route('/device/capacity/<string:uuid>', methods=['GET'], defaults={'history': None})
 def device_capacity(uuid, history):
-    device = db_controller.get_storage_device_by_id(uuid)
+    device = db_controller.get_storage_devices(uuid)
     if not device:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 
@@ -61,7 +58,7 @@ def device_capacity(uuid, history):
 @bp.route('/device/iostats/<string:uuid>/history/<string:history>', methods=['GET'])
 @bp.route('/device/iostats/<string:uuid>', methods=['GET'], defaults={'history': None})
 def device_iostats(uuid, history):
-    devices = db_controller.get_storage_device_by_id(uuid)
+    devices = db_controller.get_storage_devices(uuid)
     if not devices:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 
@@ -74,7 +71,7 @@ def device_iostats(uuid, history):
 
 @bp.route('/device/reset/<string:uuid>', methods=['GET'])
 def device_reset(uuid):
-    devices = db_controller.get_storage_device_by_id(uuid)
+    devices = db_controller.get_storage_devices(uuid)
     if not devices:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 
@@ -84,7 +81,7 @@ def device_reset(uuid):
 
 @bp.route('/device/remove/<string:uuid>', methods=['GET'])
 def device_remove(uuid):
-    devices = db_controller.get_storage_device_by_id(uuid)
+    devices = db_controller.get_storage_devices(uuid)
     if not devices:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_web/blueprints/web_api_lvol.py

@@ -19,21 +19,17 @@ bp = Blueprint("lvol", __name__)
 db_controller = kv_store.DBController()
 
 
-@bp.route('/lvol', defaults={'uuid': None, "cluster_id": None}, methods=['GET'])
-@bp.route('/lvol/<string:uuid>', defaults={"cluster_id": None}, methods=['GET'])
-@bp.route('/lvol/cluster_id/<string:cluster_id>', defaults={'uuid': None,}, methods=['GET'])
-def list_lvols(uuid, cluster_id):
+@bp.route('/lvol', defaults={'uuid': None}, methods=['GET'])
+@bp.route('/lvol/<string:uuid>', methods=['GET'])
+def list_lvols(uuid):
     if uuid:
         lvol = db_controller.get_lvol_by_id(uuid)
         if lvol:
             lvols = [lvol]
         else:
             return utils.get_response_error(f"LVol not found: {uuid}", 404)
-    elif cluster_id:
-        lvols = db_controller.get_lvols(cluster_id)
     else:
-        cluster_id = utils.get_cluster_id(request)
-        lvols = db_controller.get_lvols(cluster_id)
+        lvols = db_controller.get_lvols()
     data = []
     for lvol in lvols:
         data.append(lvol.get_clean_dict())
@@ -127,7 +123,7 @@ def add_lvol():
     if not pool:
         return utils.get_response(None, f"Pool not found: {pool_id_or_name}", 400)
 
-    for lvol in db_controller.get_lvols():  # pass
+    for lvol in db_controller.get_lvols():
         if lvol.pool_uuid == pool.get_id():
             if lvol.lvol_name == name:
                 return utils.get_response(lvol.get_id())

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_web/blueprints/web_api_pool.py

@@ -17,21 +17,17 @@ bp = Blueprint("pool", __name__)
 db_controller = kv_store.DBController()
 
 
-@bp.route('/pool', defaults={'uuid': None, "cluster_id": None}, methods=['GET'])
-@bp.route('/pool/<string:uuid>', defaults={"cluster_id": None}, methods=['GET'])
-@bp.route('/pool/cluster_id/<string:cluster_id>', defaults={'uuid': None,}, methods=['GET'])
-def list_pools(uuid, cluster_id):
+@bp.route('/pool', defaults={'uuid': None}, methods=['GET'])
+@bp.route('/pool/<string:uuid>', methods=['GET'])
+def list_pools(uuid):
     if uuid:
         pool = db_controller.get_pool_by_id(uuid)
         if pool:
             pools = [pool]
         else:
             return utils.get_response_error(f"Pool not found: {uuid}", 404)
-    elif cluster_id:
-        pools = db_controller.get_pools(cluster_id)
     else:
-        cluster_id = utils.get_cluster_id(request)
-        pools = db_controller.get_pools(cluster_id)
+        pools = db_controller.get_pools()
     data = []
     for pool in pools:
         data.append(pool.get_clean_dict())
@@ -43,7 +39,6 @@ def add_pool():
     """
         Params:
         | name (required) | LVol name or id
-        | cluster_id (required) | Cluster uuid
         | pool_max        | Pool maximum size: 10M, 10G, 10(bytes)
         | lvol_max        | LVol maximum size: 10M, 10G, 10(bytes)
         | no_secret       | pool is created with a secret
@@ -56,11 +51,7 @@ def add_pool():
     if 'name' not in pool_data:
         return utils.get_response_error("missing required param: name", 400)
 
-    if 'cluster_id' not in pool_data:
-        return utils.get_response_error("missing required param: cluster_id", 400)
-
     name = pool_data['name']
-    cluster_id = pool_data['cluster_id']
     for p in db_controller.get_pools():
         if p.pool_name == name:
             return utils.get_response_error(f"Pool found with the same name: {name}", 400)
@@ -84,7 +75,7 @@ def add_pool():
 
     ret = pool_controller.add_pool(
         name, pool_max_size, lvol_max_size, max_rw_iops, max_rw_mbytes,
-        max_r_mbytes_per_sec, max_w_mbytes_per_sec, pool_secret, cluster_id)
+        max_r_mbytes_per_sec, max_w_mbytes_per_sec, pool_secret)
 
     return utils.get_response(ret)
 

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_web/blueprints/web_api_storage_node.py

@@ -30,8 +30,7 @@ def list_storage_nodes(uuid):
         else:
             return utils.get_response_error(f"node not found: {uuid}", 404)
     else:
-        cluster_id = utils.get_cluster_id(request)
-        nodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
+        nodes = db_controller.get_storage_nodes()
     data = []
     for node in nodes:
         d = node.get_clean_dict()
@@ -180,6 +179,14 @@ def storage_node_add():
         data_nics = req_data['data_nics']
         data_nics = data_nics.split(",")
 
+    spdk_cpu_mask = None
+    if 'spdk_cpu_mask' in req_data:
+        msk = req_data['spdk_cpu_mask']
+        if utils.validate_cpu_mask(msk):
+            spdk_cpu_mask = msk
+        else:
+            return utils.get_response_error(f"Invalid cpu mask value: {msk}", 400)
+
     spdk_mem = None
     if 'spdk_mem' in req_data:
         mem = req_data['spdk_mem']
@@ -188,7 +195,7 @@ def storage_node_add():
             return utils.get_response_error(f"SPDK memory:{mem} must be larger than 1G", 400)
 
     out = storage_node_ops.add_node(
-        cluster_id, node_ip, ifname, data_nics, spdk_mem,
+        cluster_id, node_ip, ifname, data_nics, spdk_cpu_mask, spdk_mem,
         spdk_image=spdk_image, spdk_debug=spdk_debug)
 
     return utils.get_response(out)

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_web/node_utils.py

@@ -87,6 +87,8 @@ def get_nics_data():
         logger.error(err)
         return []
     data = json.loads(out)
+    logger.debug("ifaces")
+    logger.debug(data)
 
     def _get_ip4_address(list_of_addr):
         if list_of_addr:

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_web/utils.py

@@ -85,11 +85,3 @@ def get_int_value_or_default(data, key, default):
         return int(get_value_or_default(data, key, default))
     except Exception:
         return default
-
-
-def get_cluster_id(request):
-    au = request.headers["Authorization"]
-    if len(au.split()) == 2:
-        cluster_id = au.split()[0]
-        cluster_secret = au.split()[1]
-        return cluster_id