sbcli-pre 1.2.5__zip → 1.2.7__zip

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_core/cluster_ops.py

@@ -1,15 +1,19 @@
 # coding=utf-8
 import json
 import logging
-import math
 import os
+import re
+import tempfile
+import shutil
+import subprocess
 import time
 import uuid
 
 import docker
 import requests
+from jinja2 import Environment, FileSystemLoader
 
-from simplyblock_core import utils, scripts, constants, mgmt_node_ops, storage_node_ops, shell_utils
+from simplyblock_core import utils, scripts, constants, mgmt_node_ops, storage_node_ops
 from simplyblock_core.controllers import cluster_events, device_controller
 from simplyblock_core.kv_store import DBController
 from simplyblock_core.models.cluster import Cluster
@@ -17,10 +21,33 @@ from simplyblock_core.models.nvme_device import NVMeDevice
 from simplyblock_core.models.storage_node import StorageNode
 
 logger = logging.getLogger()
+TOP_DIR = os.path.dirname(os.path.dirname(os.path.realpath(__file__)))
+
+def _add_grafana_dashboards(username, password, cluster_ip):
+    url = f"http://{username}:{password}@{cluster_ip}/grafana/api/dashboards/import"
+    headers = {'Content-Type': 'application/json'}
+    dirpath, _, filenames = next(os.walk(os.path.join(constants.INSTALL_DIR, "scripts", "dashboards")))
+    ret = True
+    for filename in filenames:
+        with open(os.path.join(dirpath, filename), 'r') as f:
+            st = f.read()
+            # st = st.replace("$Cluster", cluster_id)
+            st = json.loads(st)
+        payload = json.dumps(st)
+        response = requests.post(url, headers=headers, data=payload)
+        logger.debug(response.status_code)
+        logger.debug(response.text)
+        if response.status_code == 200:
+            resp = response.json()
+            logger.info(f"Dashboard: {resp['title']}, imported: {resp['imported']}")
+        else:
+            logger.error(f"Error importing dashboard, status code:{response.status_code} text:{response.text}")
+            ret = False
+    return ret
 
 
 def _add_graylog_input(cluster_ip, password):
-    url = f"http://{cluster_ip}:9000/api/system/inputs"
+    url = f"http://{cluster_ip}/graylog/api/system/inputs"
     payload = json.dumps({
         "title": "spdk log input",
         "type": "org.graylog2.inputs.gelf.udp.GELFUDPInput",
@@ -47,7 +74,8 @@ def _add_graylog_input(cluster_ip, password):
 
 
 def create_cluster(blk_size, page_size_in_blocks, cli_pass,
-                   cap_warn, cap_crit, prov_cap_warn, prov_cap_crit, ifname, log_del_interval, metrics_retention_period):
+                   cap_warn, cap_crit, prov_cap_warn, prov_cap_crit, ifname, log_del_interval, metrics_retention_period,
+                    contact_point, grafana_endpoint):
     logger.info("Installing dependencies...")
     ret = scripts.install_deps()
     logger.info("Installing dependencies > Done")
@@ -102,6 +130,44 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
     if prov_cap_crit and prov_cap_crit > 0:
         c.prov_cap_crit = prov_cap_crit
 
+    alerts_template_folder = os.path.join(TOP_DIR, "simplyblock_core/scripts/alerting/")
+    alert_resources_file = "alert_resources.yaml"
+
+    env = Environment(loader=FileSystemLoader(alerts_template_folder), trim_blocks=True, lstrip_blocks=True)
+    template = env.get_template(f'{alert_resources_file}.j2')
+
+    slack_pattern = re.compile(r"https://hooks\.slack\.com/services/\S+")
+    email_pattern = re.compile(r"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$")
+
+    if slack_pattern.match(contact_point):
+        ALERT_TYPE = "slack"
+    elif email_pattern.match(contact_point):
+        ALERT_TYPE = "email"
+    else:
+        ALERT_TYPE = "slack"
+        contact_point = 'https://hooks.slack.com/services/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'
+
+    values = {
+        'CONTACT_POINT': contact_point,
+        'GRAFANA_ENDPOINT': grafana_endpoint,
+        'ALERT_TYPE': ALERT_TYPE,
+    }
+
+    temp_dir = tempfile.mkdtemp()
+
+    temp_file_path = os.path.join(temp_dir, alert_resources_file)
+    with open(temp_file_path, 'w') as file:
+        file.write(template.render(values))
+
+    destination_file_path = os.path.join(alerts_template_folder, alert_resources_file)
+    try:
+        subprocess.run(['sudo', '-v'], check=True) # sudo -v checks if the current user has sudo permissions
+        subprocess.run(['sudo', 'mv', temp_file_path, destination_file_path], check=True)
+        print(f"File moved to {destination_file_path} successfully.")
+    except subprocess.CalledProcessError as e:
+        print(f"An error occurred: {e}")
+    shutil.rmtree(temp_dir)
+
     logger.info("Deploying swarm stack ...")
     ret = scripts.deploy_stack(cli_pass, DEV_IP, constants.SIMPLY_BLOCK_DOCKER_IMAGE, c.secret, c.uuid, log_del_interval, metrics_retention_period)
     logger.info("Deploying swarm stack > Done")
@@ -122,8 +188,8 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
     mgmt_node_ops.add_mgmt_node(DEV_IP, c.uuid)
 
     logger.info("Applying dashboard...")
-    ret = scripts.apply_dashboard(c.secret)
-    logger.info("Applying dashboard > Done")
+    ret = _add_grafana_dashboards("admin", c.secret, DEV_IP)
+    logger.info(f"Applying dashboard > {ret}")
 
     logger.info("New Cluster has been created")
     logger.info(c.uuid)
@@ -176,203 +242,39 @@ def deploy_spdk(node_docker, spdk_cpu_mask, spdk_mem):
             break
 
 
-def join_cluster(cluster_ip, cluster_id, role, ifname, data_nics,  spdk_cpu_mask, spdk_mem):  # role: ["management", "storage"]
-
-    if role not in ["management", "storage", "storage-alloc"]:
-        logger.error(f"Unknown role: {role}")
-        return False
-
-    try:
-        resp = requests.get(f"http://{cluster_ip}/cluster/{cluster_id}")
-        resp_json = resp.json()
-        cluster_data = resp_json['results'][0]
-        logger.info(f"Cluster found! NQN:{cluster_data['nqn']}")
-        logger.debug(cluster_data)
-    except Exception as e:
-        logger.error("Error getting cluster data!")
-        logger.error(e)
-        return ""
-
-    logger.info("Installing dependencies...")
-    ret = scripts.install_deps()
-    logger.info("Installing dependencies > Done")
-
-    if not ifname:
-        ifname = "eth0"
-
-    DEV_IP = utils.get_iface_ip(ifname)
-    if not DEV_IP:
-        logger.error(f"Error getting interface ip: {ifname}")
-        return False
-
-    logger.info(f"Node IP: {DEV_IP}")
-    ret = scripts.configure_docker(DEV_IP)
-
-    db_connection = cluster_data['db_connection']
-    ret = scripts.set_db_config(db_connection)
-
-    if role == "storage":
-        logger.info("Deploying SPDK")
-        node_cpu_count = os.cpu_count()
-        if spdk_cpu_mask:
-            requested_cpu_count = len(format(int(spdk_cpu_mask, 16), 'b'))
-            if requested_cpu_count > node_cpu_count:
-                logger.error(f"The requested cpu count: {requested_cpu_count} "
-                             f"is larger than the node's cpu count: {node_cpu_count}")
-                return False
-        else:
-            spdk_cpu_mask = hex(int(math.pow(2, node_cpu_count))-1)
-        if spdk_mem:
-            spdk_mem = int(spdk_mem/(1024*1024))
-        else:
-            spdk_mem = 4096
-        node_docker = docker.DockerClient(base_url=f"tcp://{DEV_IP}:2375", version="auto", timeout=60*5)
-        deploy_spdk(node_docker, spdk_cpu_mask, spdk_mem)
-        time.sleep(5)
-
-    logger.info("Joining docker swarm...")
+def add_cluster(blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit):
     db_controller = DBController()
-    nodes = db_controller.get_mgmt_nodes(cluster_id=cluster_id)
-    if not nodes:
-        logger.error("No mgmt nodes was found in the cluster!")
-        exit(1)
+    clusters = db_controller.get_clusters()
+    if not clusters:
+        logger.error("No previous clusters found!")
+        return False
 
-    try:
-        cluster_docker = utils.get_docker_client(cluster_id)
-        docker_ip = cluster_docker.info()["Swarm"]["NodeAddr"]
+    default_cluster = clusters[0]
+    logger.info("Adding new cluster")
+    cluster = Cluster()
+    cluster.uuid = str(uuid.uuid4())
+    cluster.blk_size = blk_size
+    cluster.page_size_in_blocks = page_size_in_blocks
+    cluster.ha_type = default_cluster.ha_type
+    cluster.nqn = f"{constants.CLUSTER_NQN}:{cluster.uuid}"
+    cluster.cli_pass = default_cluster.cli_pass
+    cluster.secret = default_cluster.secret
+    cluster.db_connection = default_cluster.db_connection
+    if cap_warn and cap_warn > 0:
+        cluster.cap_warn = cap_warn
+    if cap_crit and cap_crit > 0:
+        cluster.cap_crit = cap_crit
+    if prov_cap_warn and prov_cap_warn > 0:
+        cluster.prov_cap_warn = prov_cap_warn
+    if prov_cap_crit and prov_cap_crit > 0:
+        cluster.prov_cap_crit = prov_cap_crit
 
-        if role == 'management':
-            join_token = cluster_docker.swarm.attrs['JoinTokens']['Manager']
-        else:
-            join_token = cluster_docker.swarm.attrs['JoinTokens']['Worker']
-
-        node_docker = docker.DockerClient(base_url=f"tcp://{DEV_IP}:2375", version="auto")
-        if node_docker.info()["Swarm"]["LocalNodeState"] == "active":
-            logger.info("Node is part of another swarm, leaving swarm")
-            try:
-                cluster_docker.nodes.get(node_docker.info()["Swarm"]["NodeID"]).remove(force=True)
-            except:
-                pass
-            node_docker.swarm.leave(force=True)
-            time.sleep(5)
-        node_docker.swarm.join([f"{docker_ip}:2377"], join_token)
-
-        retries = 10
-        while retries > 0:
-            if node_docker.info()["Swarm"]["LocalNodeState"] == "active":
-                break
-            logger.info("Waiting for node to be active...")
-            retries -= 1
-            time.sleep(2)
-        logger.info("Joining docker swarm > Done")
-        time.sleep(5)
+    cluster.status = Cluster.STATUS_ACTIVE
+    cluster.updated_at = int(time.time())
+    cluster.write_to_db(db_controller.kv_store)
+    cluster_events.cluster_create(cluster)
 
-    except Exception as e:
-        raise e
-
-    if role == 'management':
-        mgmt_node_ops.add_mgmt_node(DEV_IP, cluster_id)
-        cluster_obj = db_controller.get_cluster_by_id(cluster_id)
-        nodes = db_controller.get_mgmt_nodes(cluster_id=cluster_id)
-        if len(nodes) >= 3:
-            logger.info("Waiting for FDB container to be active...")
-            fdb_cont = None
-            retries = 30
-            while retries > 0 and fdb_cont is None:
-                logger.info("Looking for FDB container...")
-                for cont in node_docker.containers.list(all=True):
-                    logger.debug(cont.attrs['Name'])
-                    if cont.attrs['Name'].startswith("/app_fdb"):
-                        fdb_cont = cont
-                        break
-                if fdb_cont:
-                    logger.info("FDB container found")
-                    break
-                else:
-                    retries -= 1
-                    time.sleep(5)
-
-            if not fdb_cont:
-                logger.warning("FDB container was not found")
-            else:
-                retries = 10
-                while retries > 0:
-                    info = node_docker.containers.get(fdb_cont.attrs['Id'])
-                    status = info.attrs['State']["Status"]
-                    is_running = info.attrs['State']["Running"]
-                    if not is_running:
-                        logger.info("Container is not running, waiting...")
-                        time.sleep(3)
-                        retries -= 1
-                    else:
-                        logger.info(f"Container status: {status}, Is Running: {is_running}")
-                    break
-
-            logger.info("Configuring Double DB...")
-            time.sleep(3)
-            out = scripts.set_db_config_double()
-            cluster_obj.ha_type = "ha"
-            cluster_obj.write_to_db(db_controller.kv_store)
-            logger.info("Configuring DB > Done")
-
-    elif role == "storage":
-        # add storage node
-        fdb_cont = None
-        retries = 30
-        while retries > 0 and fdb_cont is None:
-            logger.info("Looking for SpdkAppProxy container...")
-            for cont in node_docker.containers.list(all=True):
-                logger.debug(cont.attrs['Name'])
-                if cont.attrs['Name'].startswith("/app_SpdkAppProxy"):
-                    fdb_cont = cont
-                    break
-            if fdb_cont:
-                logger.info("SpdkAppProxy container found")
-                break
-            else:
-                retries -= 1
-                time.sleep(5)
-
-        if not fdb_cont:
-            logger.warning("SpdkAppProxy container was not found")
-        else:
-            retries = 10
-            while retries > 0:
-                info = node_docker.containers.get(fdb_cont.attrs['Id'])
-                status = info.attrs['State']["Status"]
-                is_running = info.attrs['State']["Running"]
-                if not is_running:
-                    logger.info("Container is not running, waiting...")
-                    time.sleep(3)
-                    retries -= 1
-                else:
-                    logger.info(f"Container status: {status}, Is Running: {is_running}")
-                break
-        storage_node_ops.add_storage_node(cluster_id, ifname, data_nics)
-
-    logger.info("Node joined the cluster")
-
-
-def add_cluster(blk_size, page_size_in_blocks, model_ids, tls,
-                auth_hosts_only, dhchap, nqn, iscsi, cli_pass):
-    db_controller = DBController()
-    logger.info("Adding new cluster")
-    c = Cluster()
-    c.uuid = str(uuid.uuid4())
-    c.blk_size = blk_size
-    c.page_size_in_blocks = page_size_in_blocks
-    c.model_ids = model_ids
-    c.tls = tls
-    c.auth_hosts_only = auth_hosts_only
-    c.nqn = nqn
-    c.iscsi = iscsi
-    c.dhchap = dhchap
-    c.cli_pass = cli_pass
-    c.status = Cluster.STATUS_ACTIVE
-    c.updated_at = int(time.time())
-    c.write_to_db(db_controller.kv_store)
-    logger.info("New Cluster has been created")
-    logger.info(c.uuid)
+    return cluster.get_id()
 
 
 def show_cluster(cl_id, is_json=False):
@@ -382,7 +284,7 @@ def show_cluster(cl_id, is_json=False):
         logger.error(f"Cluster not found {cl_id}")
         return False
 
-    st = db_controller.get_storage_nodes()
+    st = db_controller.get_storage_nodes_by_cluster_id(cl_id)
     data = []
     for node in st:
         for dev in node.nvme_devices:
@@ -443,7 +345,7 @@ def cluster_set_read_only(cl_id):
 
     ret = set_cluster_status(cl_id, Cluster.STATUS_READONLY)
     if ret:
-        st = db_controller.get_storage_nodes()
+        st = db_controller.get_storage_nodes_by_cluster_id(cl_id)
         for node in st:
             for dev in node.nvme_devices:
                 if dev.status == NVMeDevice.STATUS_ONLINE:
@@ -463,7 +365,7 @@ def cluster_set_active(cl_id):
 
     ret = set_cluster_status(cl_id, Cluster.STATUS_ACTIVE)
     if ret:
-        st = db_controller.get_storage_nodes()
+        st = db_controller.get_storage_nodes_by_cluster_id(cl_id)
         for node in st:
             for dev in node.nvme_devices:
                 if dev.status == NVMeDevice.STATUS_READONLY:
@@ -474,11 +376,11 @@ def cluster_set_active(cl_id):
 def list():
     db_controller = DBController()
     cls = db_controller.get_clusters()
-    st = db_controller.get_storage_nodes()
     mt = db_controller.get_mgmt_nodes()
 
     data = []
     for cl in cls:
+        st = db_controller.get_storage_nodes_by_cluster_id(cl.get_id())
         data.append({
             "UUID": cl.id,
             "NQN": cl.nqn,
@@ -623,7 +525,7 @@ def get_logs(cluster_id, is_json=False):
             vuid = record.object_dict['vuid']
 
         out.append({
-            "Date": time.strftime("%H:%M:%S, %d/%m/%Y", time.gmtime(record.date)),
+            "Date": record.get_date_string(),
             "NodeId": record.node_id,
             "Event": record.event,
             "Level": record.event_level,
@@ -655,12 +557,12 @@ def update_cluster(cl_id):
         logger.error(f"Cluster not found {cl_id}")
         return False
 
-    try:
-        out, _, ret_code = shell_utils.run_command("pip install sbcli-dev --upgrade")
-        if ret_code == 0:
-            logger.info("sbcli-dev is upgraded")
-    except Exception as e:
-        logger.error(e)
+    # try:
+    #     out, _, ret_code = shell_utils.run_command("pip install sbcli-dev --upgrade")
+    #     if ret_code == 0:
+    #         logger.info("sbcli-dev is upgraded")
+    # except Exception as e:
+    #     logger.error(e)
 
     try:
         logger.info("Updating mgmt cluster")
@@ -675,7 +577,7 @@ def update_cluster(cl_id):
     except Exception as e:
         print(e)
 
-    for node in db_controller.get_storage_nodes():
+    for node in db_controller.get_storage_nodes_by_cluster_id(cl_id):
         node_docker = docker.DockerClient(base_url=f"tcp://{node.mgmt_ip}:2375", version="auto")
         logger.info(f"Pulling image {constants.SIMPLY_BLOCK_SPDK_ULTRA_IMAGE}")
         node_docker.images.pull(constants.SIMPLY_BLOCK_SPDK_ULTRA_IMAGE)
@@ -688,28 +590,6 @@ def update_cluster(cl_id):
     return True
 
 
-def list_tasks(cluster_id):
-    db_controller = DBController()
-    cluster = db_controller.get_cluster_by_id(cluster_id)
-    if not cluster:
-        logger.error("Cluster not found: %s", cluster_id)
-        return False
-
-    data = []
-    tasks = db_controller.get_job_tasks(cluster_id)
-    for task in tasks:
-        data.append({
-            "UUID": task.uuid,
-            "Device": task.device_id,
-            "Function": task.function_name,
-            "Retry": f"{task.retry}/{constants.TASK_EXEC_RETRY_COUNT}",
-            "Status": task.status,
-            "Result": task.function_result,
-            "Date": time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(task.date)),
-        })
-    return utils.print_table(data)
-
-
 def cluster_grace_startup(cl_id):
     db_controller = DBController()
     cluster = db_controller.get_cluster_by_id(cl_id)
@@ -719,7 +599,7 @@ def cluster_grace_startup(cl_id):
     logger.info(f"Unsuspending cluster: {cl_id}")
     unsuspend_cluster(cl_id)
 
-    st = db_controller.get_storage_nodes()
+    st = db_controller.get_storage_nodes_by_cluster_id(cl_id)
     for node in st:
         logger.info(f"Restarting node: {node.get_id()}")
         storage_node_ops.restart_storage_node(node.get_id())
@@ -738,7 +618,7 @@ def cluster_grace_shutdown(cl_id):
         logger.error(f"Cluster not found {cl_id}")
         return False
 
-    st = db_controller.get_storage_nodes()
+    st = db_controller.get_storage_nodes_by_cluster_id(cl_id)
     for node in st:
         logger.info(f"Suspending node: {node.get_id()}")
         storage_node_ops.suspend_storage_node(node.get_id())
@@ -748,3 +628,26 @@ def cluster_grace_shutdown(cl_id):
     logger.info(f"Suspending cluster: {cl_id}")
     suspend_cluster(cl_id)
     return True
+
+
+def delete_cluster(cl_id):
+    db_controller = DBController()
+    cluster = db_controller.get_cluster_by_id(cl_id)
+    if not cluster:
+        logger.error(f"Cluster not found {cl_id}")
+        return False
+
+    nodes = db_controller.get_storage_nodes_by_cluster_id(cl_id)
+    if nodes:
+        logger.error("Can only remove Empty cluster, Storage nodes found")
+        return False
+
+    pools = db_controller.get_pools(cl_id)
+    if pools:
+        logger.error("Can only remove Empty cluster, Pools found")
+        return False
+
+    logger.info(f"Deleting Cluster {cl_id}")
+    cluster_events.cluster_delete(cluster)
+    cluster.remove(db_controller.kv_store)
+    logger.info("Done")

sbcli_pre-1.2.7/simplyblock_core/constants.py

@@ -0,0 +1,91 @@
+import logging
+import os
+
+KVD_DB_VERSION = 730
+KVD_DB_FILE_PATH = '/etc/foundationdb/fdb.cluster'
+KVD_DB_TIMEOUT_MS = 10000
+SPK_DIR = '/home/ec2-user/spdk'
+RPC_HTTP_PROXY_PORT = 8080
+LOG_LEVEL = logging.INFO
+LOG_WEB_DEBUG = True
+
+INSTALL_DIR = os.path.dirname(os.path.realpath(__file__))
+
+NODE_MONITOR_INTERVAL_SEC = 3
+DEVICE_MONITOR_INTERVAL_SEC = 5
+STAT_COLLECTOR_INTERVAL_SEC = 60*5  # 5 minutes
+LVOL_STAT_COLLECTOR_INTERVAL_SEC = 2
+LVOL_MONITOR_INTERVAL_SEC = 60
+DEV_MONITOR_INTERVAL_SEC = 10
+DEV_STAT_COLLECTOR_INTERVAL_SEC = 2
+PROT_STAT_COLLECTOR_INTERVAL_SEC = 2
+DISTR_EVENT_COLLECTOR_INTERVAL_SEC = 2
+DISTR_EVENT_COLLECTOR_NUM_OF_EVENTS = 10
+CAP_MONITOR_INTERVAL_SEC = 30
+SSD_VENDOR_WHITE_LIST = ["1d0f:cd01", "1d0f:cd00"]
+
+PMEM_DIR = '/tmp/pmem'
+
+NVME_PROGRAM_FAIL_COUNT = 50
+NVME_ERASE_FAIL_COUNT = 50
+NVME_CRC_ERROR_COUNT = 50
+DEVICE_OVERLOAD_STDEV_VALUE = 50
+DEVICE_OVERLOAD_CAPACITY_THRESHOLD = 50
+
+CLUSTER_NQN = "nqn.2023-02.io.simplyblock"
+
+weights = {
+    "lvol": 50,
+    "cpu": 10,
+    "r_io": 10,
+    "w_io": 10,
+    "r_b": 10,
+    "w_b": 10
+}
+
+# To use 75% of hugepages to calculate ssd size to use for the ocf bdev
+CACHING_NODE_MEMORY_FACTOR = 0.75
+
+HEALTH_CHECK_INTERVAL_SEC = 60
+
+GRAYLOG_CHECK_INTERVAL_SEC = 60
+
+FDB_CHECK_INTERVAL_SEC = 60
+
+SIMPLY_BLOCK_DOCKER_IMAGE = "simplyblock/simplyblock:pre-release"
+SIMPLY_BLOCK_CLI_NAME = "sbcli"
+TASK_EXEC_INTERVAL_SEC = 30
+TASK_EXEC_RETRY_COUNT = 8
+
+SIMPLY_BLOCK_SPDK_CORE_IMAGE = "simplyblock/spdk-core:latest"
+SIMPLY_BLOCK_SPDK_ULTRA_IMAGE = "simplyblock/spdk:prerelease-latest"
+
+GELF_PORT = 12201
+
+MIN_HUGE_PAGE_MEMORY_FOR_LVOL = 209715200
+MIN_SYS_MEMORY_FOR_LVOL = 524288000
+EXTRA_SMALL_POOL_COUNT = 1024
+EXTRA_LARGE_POOL_COUNT = 128
+EXTRA_HUGE_PAGE_MEMORY = 2147483648
+EXTRA_SYS_MEMORY = 2147483648
+
+INSTANCE_STORAGE_DATA = {
+        'i4i.large': {'number_of_devices': 1, 'size_per_device_gb': 468},
+        'i4i.xlarge': {'number_of_devices': 1, 'size_per_device_gb': 937},
+        'i4i.2xlarge': {'number_of_devices': 1, 'size_per_device_gb': 1875},
+        'i4i.4xlarge': {'number_of_devices': 1, 'size_per_device_gb': 3750},
+        'i4i.8xlarge': {'number_of_devices': 2, 'size_per_device_gb': 3750},
+        'i4i.12xlarge': {'number_of_devices': 3, 'size_per_device_gb': 3750},
+        'i4i.16xlarge': {'number_of_devices': 4, 'size_per_device_gb': 3750},
+        'i4i.24xlarge': {'number_of_devices': 6, 'size_per_device_gb': 3750},
+        'i4i.32xlarge': {'number_of_devices': 8, 'size_per_device_gb': 3750},
+        'i4i.metal': {'number_of_devices': 8, 'size_per_device_gb': 3750},
+        'i3en.large': {'number_of_devices': 1, 'size_per_device_gb': 1250},
+        'i3en.xlarge': {'number_of_devices': 1, 'size_per_device_gb': 2500},
+        'i3en.2xlarge': {'number_of_devices': 2, 'size_per_device_gb': 2500},
+        'i3en.3xlarge': {'number_of_devices': 1, 'size_per_device_gb': 7500},
+        'i3en.6xlarge': {'number_of_devices': 2, 'size_per_device_gb': 7500},
+        'i3en.12xlarge': {'number_of_devices': 4, 'size_per_device_gb': 7500},
+        'i3en.24xlarge': {'number_of_devices': 8, 'size_per_device_gb': 7500},
+        'i3en.metal': {'number_of_devices': 8, 'size_per_device_gb': 7500},
+    }

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_core/controllers/caching_node_controller.py

@@ -66,7 +66,6 @@ def addNvmeDevices(cluster, rpc_client, devs, snode):
                     'model_id': model_number,
                     'serial_number': nvme_driver_data['ctrlr_data']['serial_number'],
                     'nvme_bdev': nvme_bdev,
-                    'alloc_bdev': nvme_bdev,
                     'node_id': snode.get_id(),
                     'cluster_id': snode.cluster_id,
                     'status': 'online'
@@ -88,10 +87,10 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list, spdk_cpu_mask, spd
     snode_api = CNodeClient(node_ip)
 
     node_info, _ = snode_api.info()
-    logger.info(f"Node found: {node_info['hostname']}")
-
+    system_id = node_info['system_id']
     hostname = node_info['hostname']
-    snode = db_controller.get_storage_node_by_hostname(hostname)
+    logger.info(f"Node found: {node_info['hostname']}")
+    snode = db_controller.get_caching_node_by_system_id(system_id)
     if snode:
         logger.error("Node already exists, try remove it first.")
         return False
@@ -119,9 +118,8 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list, spdk_cpu_mask, spd
     snode.uuid = str(uuid.uuid4())
     snode.status = CachingNode.STATUS_IN_CREATION
     # snode.baseboard_sn = node_info['system_id']
-    snode.system_uuid = node_info['system_id']
+    snode.system_uuid = system_id
     snode.hostname = hostname
-    # snode.host_nqn = subsystem_nqn
     snode.subsystem = subsystem_nqn
     snode.data_nics = data_nics
     snode.mgmt_ip = node_info['network_interface'][iface_name]['ip']
@@ -350,6 +348,10 @@ def connect(caching_node_id, lvol_id):
             logger.info(f"Already connected, dev path: {clvol.device_path}")
             return False
 
+    if cnode.cluster_id != pool.cluster_id:
+        logger.error("Caching node and LVol are in different clusters")
+        return False
+
     logger.info("Connecting to remote LVOL")
     mini_id = lvol.get_id().split("-")[0]
     rem_name = f"rem_{mini_id}"

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_core/controllers/cluster_events.py

@@ -60,3 +60,12 @@ def cluster_prov_cap_crit(cluster, util):
     msg = f"Cluster provisioned capacity reached: {util}%"
     _cluster_cap_event(cluster, msg, event_level=EventObj.LEVEL_CRITICAL)
 
+
+def cluster_delete(cluster):
+    ec.log_event_cluster(
+        cluster_id=cluster.get_id(),
+        domain=ec.DOMAIN_CLUSTER,
+        event=ec.EVENT_OBJ_DELETED,
+        db_object=cluster,
+        caused_by=ec.CAUSED_BY_CLI,
+        message=f"Cluster deleted {cluster.get_id()}")