sbcli-pre 1.2.5__zip → 1.2.6__zip

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_core/utils.py

@@ -257,7 +257,7 @@ def process_records(records, records_count):
 
 def ping_host(ip):
     logger.debug(f"Pinging ip ... {ip}")
-    response = os.system(f"ping -c 1 {ip} > /dev/null")
+    response = os.system(f"ping -c 1 -W 3 {ip} > /dev/null")
     if response == 0:
         logger.debug(f"{ip} is UP")
         return True
@@ -280,3 +280,48 @@ def sum_records(records):
 
 def get_random_vuid():
     return 1 + int(random.random() * 10000)
+
+
+def calculate_core_allocation(cpu_count):
+    '''
+    If number of cpu cores >= 8, tune cpu core mask
+        1. Never use core 0 for spdk.
+        2. For every 8 cores, leave one core to the operating system
+        3. Do not use more than 15% of remaining available cores for nvme pollers
+        4. Use one dedicated core for app_thread
+        5. distribute distrib bdevs and alceml bdevs to all other cores
+    JIRA ticket link/s
+    https://simplyblock.atlassian.net/browse/SFAM-885
+    '''
+
+    all_cores = list(range(0, cpu_count))
+    # Calculate the number of cores to exclude for the OS
+    if cpu_count == 8:
+        os_cores_count = 1
+    else:
+        os_cores_count = 1 + (cpu_count // 8)
+
+    # Calculate os cores
+    os_cores = all_cores[0:os_cores_count]
+
+    # Calculate available cores
+    available_cores_count = cpu_count - os_cores_count
+
+    # Calculate NVMe pollers
+    nvme_pollers_count = int(available_cores_count * 0.15)
+    nvme_pollers_cores = all_cores[os_cores_count:os_cores_count + nvme_pollers_count]
+
+    # Allocate core for app_thread
+    app_thread_core = all_cores[os_cores_count + nvme_pollers_count:os_cores_count + nvme_pollers_count + 1]
+
+    # Calculate bdb_lcpu cores
+    bdb_lcpu_cores = all_cores[os_cores_count + nvme_pollers_count + 1:]
+
+    return os_cores, nvme_pollers_cores, app_thread_core, bdb_lcpu_cores
+
+
+def generate_mask(cores):
+    mask = 0
+    for core in cores:
+        mask |= (1 << core)
+    return f'0x{mask:X}'

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_web/blueprints/snode_ops.py

@@ -14,7 +14,8 @@ from flask import request
 
 from simplyblock_web import utils, node_utils
 
-from simplyblock_core import scripts, constants
+from simplyblock_core import scripts, constants, shell_utils
+from ec2_metadata import ec2_metadata
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -22,11 +23,24 @@ bp = Blueprint("snode", __name__, url_prefix="/snode")
 
 cluster_id_file = "/etc/foundationdb/sbcli_cluster_id"
 
-cpu_info = cpuinfo.get_cpu_info()
-hostname, _, _ = node_utils.run_command("hostname -s")
-system_id = ""
+CPU_INFO = cpuinfo.get_cpu_info()
+HOSTNAME, _, _ = node_utils.run_command("hostname -s")
+SYSTEM_ID = ""
+EC2_PUBLIC_IP = ""
+EC2_MD = ""
+
 try:
-    system_id, _, _ = node_utils.run_command("dmidecode -s system-uuid")
+    SYSTEM_ID = ec2_metadata.instance_id
+except:
+    SYSTEM_ID, _, _ = node_utils.run_command("dmidecode -s system-uuid")
+
+try:
+    EC2_PUBLIC_IP = ec2_metadata.public_ipv4
+except:
+    pass
+
+try:
+    EC2_MD = ec2_metadata.instance_identity_document
 except:
     pass
 
@@ -67,23 +81,10 @@ def spdk_process_start():
     spdk_cpu_mask = None
     if 'spdk_cpu_mask' in data:
         spdk_cpu_mask = data['spdk_cpu_mask']
+
     spdk_mem = None
     if 'spdk_mem' in data:
         spdk_mem = data['spdk_mem']
-    node_cpu_count = os.cpu_count()
-
-    if spdk_cpu_mask:
-        try:
-            requested_cpu_count = len(format(int(spdk_cpu_mask, 16), 'b'))
-            if requested_cpu_count > node_cpu_count:
-                return utils.get_response(
-                    False,
-                    f"The requested cpu count: {requested_cpu_count} "
-                    f"is larger than the node's cpu count: {node_cpu_count}")
-        except:
-            spdk_cpu_mask = hex(int(math.pow(2, node_cpu_count)) - 1)
-    else:
-        spdk_cpu_mask = hex(int(math.pow(2, node_cpu_count)) - 1)
 
     if spdk_mem:
         spdk_mem = int(utils.parse_size(spdk_mem) / (1000 * 1000))
@@ -229,11 +230,11 @@ def get_info():
     out = {
         "cluster_id": get_cluster_id(),
 
-        "hostname": hostname,
-        "system_id": system_id,
+        "hostname": HOSTNAME,
+        "system_id": SYSTEM_ID,
 
-        "cpu_count": cpu_info['count'],
-        "cpu_hz": cpu_info['hz_advertised'][0],
+        "cpu_count": CPU_INFO['count'],
+        "cpu_hz": CPU_INFO['hz_advertised'][0],
 
         "memory": node_utils.get_memory(),
         "hugepages": node_utils.get_huge_memory(),
@@ -247,9 +248,9 @@ def get_info():
 
         "network_interface": node_utils.get_nics_data(),
 
-        "ec2_metadata": get_ec2_meta(),
+        "ec2_metadata": EC2_MD,
 
-        "ec2_public_ip": get_ec2_public_ip(),
+        "ec2_public_ip": EC2_PUBLIC_IP,
     }
     return utils.get_response(out)
 
@@ -303,3 +304,80 @@ def leave_swarm():
     except:
         pass
     return utils.get_response(True)
+
+
+@bp.route('/make_gpt_partitions', methods=['POST'])
+def make_gpt_partitions_for_nbd():
+    nbd_device = '/dev/nbd0'
+    jm_percent = '3'
+    num_partitions = 1
+
+    try:
+        data = request.get_json()
+        nbd_device = data['nbd_device']
+        jm_percent = data['jm_percent']
+        num_partitions = data['num_partitions']
+    except:
+        pass
+
+    cmd_list = [
+        f"parted -fs {nbd_device} mklabel gpt",
+        f"parted -f {nbd_device} mkpart journal \"0%\" \"{jm_percent}%\""
+    ]
+    sg_cmd_list = [
+        f"sgdisk -t 1:6527994e-2c5a-4eec-9613-8f5944074e8b {nbd_device}",
+    ]
+    perc_per_partition = int((100 - jm_percent) / num_partitions)
+    for i in range(num_partitions):
+        st = jm_percent + (i * perc_per_partition)
+        en = st + perc_per_partition
+        cmd_list.append(f"parted -f {nbd_device} mkpart part{(i+1)} \"{st}%\" \"{en}%\"")
+        sg_cmd_list.append(f"sgdisk -t {(i+2)}:6527994e-2c5a-4eec-9613-8f5944074e8b {nbd_device}")
+
+    for cmd in cmd_list+sg_cmd_list:
+        logger.debug(cmd)
+        out, err, ret_code = shell_utils.run_command(cmd)
+        logger.debug(out)
+        logger.debug(ret_code)
+        if ret_code != 0:
+            logger.error(err)
+            return utils.get_response(False, f"Error running cmd: {cmd}, returncode: {ret_code}, output: {out}, err: {err}")
+        time.sleep(1)
+
+    return utils.get_response(True)
+
+
+@bp.route('/delete_dev_gpt_partitions', methods=['POST'])
+def delete_gpt_partitions_for_dev():
+
+    data = request.get_json()
+
+    if "device_pci" not in data:
+        return utils.get_response(False, "Required parameter is missing: device_pci")
+
+    device_pci = data['device_pci']
+
+    cmd_list = [
+        f"echo -n \"{device_pci}\" > /sys/bus/pci/drivers/uio_pci_generic/unbind",
+        f"echo -n \"{device_pci}\" > /sys/bus/pci/drivers/nvme/bind",
+    ]
+
+    for cmd in cmd_list:
+        logger.debug(cmd)
+        ret = os.popen(cmd).read().strip()
+        logger.debug(ret)
+        time.sleep(1)
+
+    device_name = os.popen(f"ls /sys/devices/pci0000:00/{device_pci}/nvme/nvme*/ | grep nvme").read().strip()
+    cmd_list = [
+        f"parted -fs /dev/{device_name} mklabel gpt",
+        f"echo -n \"{device_pci}\" > /sys/bus/pci/drivers/nvme/unbind",
+    ]
+
+    for cmd in cmd_list:
+        logger.debug(cmd)
+        ret = os.popen(cmd).read().strip()
+        logger.debug(ret)
+        time.sleep(1)
+
+    return utils.get_response(True)

{sbcli_pre-1.2.5 → sbcli_pre-1.2.6}/simplyblock_web/blueprints/web_api_cluster.py

@@ -22,50 +22,27 @@ db_controller = kv_store.DBController()
 
 @bp.route('/cluster', methods=['POST'])
 def add_cluster():
+
+    blk_size = 512
+    page_size_in_blocks = 2097152
+    cap_warn = 0
+    cap_crit = 0
+    prov_cap_warn = 0
+    prov_cap_crit = 0
+
     cl_data = request.get_json()
-    if 'blk_size' not in cl_data:
-        return utils.get_response_error("missing required param: blk_size", 400)
-    if 'page_size_in_blocks' not in cl_data:
-        return utils.get_response_error("missing required param: page_size_in_blocks", 400)
-    if 'model_ids' not in cl_data:
-        return utils.get_response_error("missing required param: model_ids", 400)
-    if 'ha_type' not in cl_data:
-        return utils.get_response_error("missing required param: ha_type", 400)
-    if 'tls' not in cl_data:
-        return utils.get_response_error("missing required param: tls", 400)
-    if 'auth-hosts-only' not in cl_data:
-        return utils.get_response_error("missing required param: auth-hosts-only", 400)
-    if 'dhchap' not in cl_data:
-        return utils.get_response_error("missing required param: dhchap", 400)
-    if 'NQN' not in cl_data:
-        return utils.get_response_error("missing required param: NQN", 400)
-
-    c = Cluster()
-    c.uuid = str(uuid.uuid4())
-
-    if cl_data['blk_size'] not in [512, 4096]:
-        return utils.get_response_error("blk_size can be 512 or 4096", 400)
-
-    if cl_data['ha_type'] not in ["single", "ha"]:
-        return utils.get_response_error("ha_type can be single or ha", 400)
-
-    if cl_data['dhchap'] not in ["off", "one-way", "bi-direct"]:
-        return utils.get_response_error("dhchap can be off, one-way or bi-direct", 400)
-
-    c.blk_size = cl_data['blk_size']
-    c.page_size_in_blocks = cl_data['page_size_in_blocks']
-    c.model_ids = cl_data['model_ids']
-    c.ha_type = cl_data['ha_type']
-    c.tls = cl_data['tls']
-    c.auth_hosts_only = cl_data['auth-hosts-only']
-    c.nqn = cl_data['nqn']
-    c.iscsi = cl_data['iscsi'] or False
-    c.dhchap = cl_data['dhchap']
-    c.cluster_status = Cluster.STATUS_ACTIVE
-    c.updated_at = int(time.time())
-    c.write_to_db(db_controller.kv_store)
-
-    return utils.get_response(c.to_dict()), 201
+    if 'blk_size' in cl_data:
+        if cl_data['blk_size'] not in [512, 4096]:
+            return utils.get_response_error("blk_size can be 512 or 4096", 400)
+        else:
+            blk_size = cl_data['blk_size']
+
+    if 'page_size_in_blocks' in cl_data:
+        page_size_in_blocks = cl_data['page_size_in_blocks']
+
+    ret = cluster_ops.add_cluster(blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit)
+
+    return utils.get_response(ret)
 
 
 @bp.route('/cluster', methods=['GET'], defaults={'uuid': None})

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

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

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

@@ -19,17 +19,21 @@ bp = Blueprint("lvol", __name__)
 db_controller = kv_store.DBController()
 
 
-@bp.route('/lvol', defaults={'uuid': None}, methods=['GET'])
-@bp.route('/lvol/<string:uuid>', methods=['GET'])
-def list_lvols(uuid):
+@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):
     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:
-        lvols = db_controller.get_lvols()
+        cluster_id = utils.get_cluster_id(request)
+        lvols = db_controller.get_lvols(cluster_id)
     data = []
     for lvol in lvols:
         data.append(lvol.get_clean_dict())
@@ -123,7 +127,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():
+    for lvol in db_controller.get_lvols():  # pass
         if lvol.pool_uuid == pool.get_id():
             if lvol.lvol_name == name:
                 return utils.get_response(lvol.get_id())

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

@@ -17,17 +17,21 @@ bp = Blueprint("pool", __name__)
 db_controller = kv_store.DBController()
 
 
-@bp.route('/pool', defaults={'uuid': None}, methods=['GET'])
-@bp.route('/pool/<string:uuid>', methods=['GET'])
-def list_pools(uuid):
+@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):
     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:
-        pools = db_controller.get_pools()
+        cluster_id = utils.get_cluster_id(request)
+        pools = db_controller.get_pools(cluster_id)
     data = []
     for pool in pools:
         data.append(pool.get_clean_dict())
@@ -39,6 +43,7 @@ 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
@@ -51,7 +56,11 @@ 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)
@@ -75,7 +84,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)
+        max_r_mbytes_per_sec, max_w_mbytes_per_sec, pool_secret, cluster_id)
 
     return utils.get_response(ret)
 

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

@@ -30,7 +30,8 @@ def list_storage_nodes(uuid):
         else:
             return utils.get_response_error(f"node not found: {uuid}", 404)
     else:
-        nodes = db_controller.get_storage_nodes()
+        cluster_id = utils.get_cluster_id(request)
+        nodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
     data = []
     for node in nodes:
         d = node.get_clean_dict()
@@ -179,14 +180,6 @@ 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']
@@ -195,7 +188,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_cpu_mask, spdk_mem,
+        cluster_id, node_ip, ifname, data_nics, spdk_mem,
         spdk_image=spdk_image, spdk_debug=spdk_debug)
 
     return utils.get_response(out)

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

@@ -87,8 +87,6 @@ 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.5 → sbcli_pre-1.2.6}/simplyblock_web/utils.py

@@ -85,3 +85,11 @@ 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

sbcli_pre-1.2.5/simplyblock_core/mgmt_node_ops.py

@@ -1,80 +0,0 @@
-# coding=utf-8
-import json
-import logging
-import uuid
-
-import docker
-
-from simplyblock_core import utils
-from simplyblock_core.controllers import mgmt_events
-from simplyblock_core.kv_store import DBController
-from simplyblock_core.models.mgmt_node import MgmtNode
-
-logger = logging.getLogger()
-
-
-def add_mgmt_node(mgmt_ip, cluster_id=None):
-    db_controller = DBController()
-    hostname = utils.get_hostname()
-    node = db_controller.get_mgmt_node_by_hostname(hostname)
-    if node:
-        logger.error("Node already exists in the cluster")
-        return False
-
-    node = MgmtNode()
-    node.uuid = str(uuid.uuid4())
-    node.hostname = hostname
-    node.docker_ip_port = f"{mgmt_ip}:2375"
-    node.cluster_id = cluster_id
-    node.mgmt_ip = mgmt_ip
-    node.status = MgmtNode.STATUS_ONLINE
-    node.write_to_db(db_controller.kv_store)
-
-    mgmt_events.mgmt_add(node)
-    logger.info("Done")
-    return True
-
-
-def list_mgmt_nodes(is_json):
-    db_controller = DBController()
-    nodes = db_controller.get_mgmt_nodes()
-    data = []
-    output = ""
-
-    for node in nodes:
-        logging.debug(node)
-        logging.debug("*" * 20)
-        data.append({
-            "UUID": node.get_id(),
-            "Hostname": node.hostname,
-            "IP": node.mgmt_ip,
-            "Status": node.status,
-        })
-
-    if not data:
-        return output
-
-    if is_json:
-        output = json.dumps(data, indent=2)
-    else:
-        output = utils.print_table(data)
-    return output
-
-
-def remove_mgmt_node(uuid):
-    db_controller = DBController()
-    snode = db_controller.get_mgmt_node_by_id(uuid)
-    if not snode:
-        logger.error("can not find node")
-        return False
-
-    logging.info("Removing mgmt node")
-    snode.remove(db_controller.kv_store)
-
-    logger.info("Leaving swarm...")
-    node_docker = docker.DockerClient(base_url=f"tcp://{snode.docker_ip_port}", version="auto")
-    node_docker.swarm.leave()
-
-    mgmt_events.mgmt_remove(snode)
-    logging.info("done")
-

sbcli_pre-1.2.5/simplyblock_core/scripts/apply_dashboard.sh

@@ -1,22 +0,0 @@
-#!/bin/bash
-
-TD=$(dirname -- "$(readlink -f -- "$0")")
-
-# Grafana Password
-export grafanaPassword=$1
-
-# Grafana username
-GF_ADMIN_USER=admin
-
-HOST=0.0.0.0:3000
-
-DASHBOARDS="${TD}/dashboards"
-for dashboard in "${DASHBOARDS}/cluster.json" "${DASHBOARDS}/devices.json" "${DASHBOARDS}/nodes.json" "${DASHBOARDS}/lvols.json" "${DASHBOARDS}/pools.json" "${DASHBOARDS}/node-exporter.json"; do
-    echo -e "\nUploading dashboard: ${dashboard}"
-    curl -X POST -H "Content-Type: application/json" \
-        -d "@${dashboard}" \
-        "http://${GF_ADMIN_USER}:${grafanaPassword}@${HOST}/api/dashboards/import"
-    echo ""
-done
-
-echo "Cluster deployment complete."