sbcli-pre 1.2.5__zip → 1.2.7__zip

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

@@ -17,7 +17,7 @@ from simplyblock_core.models.pool import Pool
 from simplyblock_core.models.lvol_model import LVol
 from simplyblock_core.models.storage_node import StorageNode
 from simplyblock_core.rpc_client import RPCClient
-
+from simplyblock_core.snode_client import SNodeClient
 
 logger = lg.getLogger()
 db_controller = DBController()
@@ -125,7 +125,7 @@ def validate_add_lvol_func(name, size, host_id_or_name, pool_id_or_name,
             return False, f"Invalid LVol size: {utils.humanbytes(size)} " \
                           f"Pool max size has reached {utils.humanbytes(total)} of {utils.humanbytes(pool.pool_max_size)}"
 
-    for lvol in db_controller.get_lvols():
+    for lvol in db_controller.get_lvols(pool.cluster_id):
         if lvol.pool_uuid == pool.get_id():
             if lvol.lvol_name == name:
                 return False, f"LVol name must be unique: {name}"
@@ -167,7 +167,7 @@ def validate_add_lvol_func(name, size, host_id_or_name, pool_id_or_name,
 
 
 def get_jm_names(snode):
-    return [f"jm_{snode.get_id()}"]
+    return [snode.jm_device.jm_bdev] if snode.jm_device else []
 
 
 # Deprecated
@@ -218,7 +218,7 @@ def add_lvol(name, size, host_id_or_name, pool_id_or_name, use_comp, use_crypto,
         return False, "Storage node has no nvme devices"
 
     dev_count = 0
-    for node in db_controller.get_storage_nodes():
+    for node in db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id):
         if node.status == node.STATUS_ONLINE:
             for dev in node.nvme_devices:
                 if dev.status == dev.STATUS_ONLINE:
@@ -252,7 +252,7 @@ def add_lvol(name, size, host_id_or_name, pool_id_or_name, use_comp, use_crypto,
             distr_npcs = 1
         else:
             node_count = 0
-            for node in db_controller.get_storage_nodes():
+            for node in db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id):
                 if node.status == node.STATUS_ONLINE:
                     node_count += 1
             if node_count == 3:
@@ -265,7 +265,7 @@ def add_lvol(name, size, host_id_or_name, pool_id_or_name, use_comp, use_crypto,
 
     # name, vuid, ndcs, npcs, num_blocks, block_size, alloc_names
     ret = rpc_client.bdev_distrib_create(f"distr_{name}", vuid, distr_ndcs, distr_npcs, num_blocks, distr_bs, jm_names,
-                                         distr_chunk_bs)
+                                         distr_chunk_bs, dev_cpu_mask=snode.dev_cpu_mask)
     bdev_stack.append({"type": "distr", "name": f"distr_{name}"})
     if not ret:
         logger.error("failed to create Distr bdev")
@@ -364,12 +364,23 @@ def add_lvol(name, size, host_id_or_name, pool_id_or_name, use_comp, use_crypto,
     return lvol_id, None
 
 
-def _get_next_3_nodes():
-    snodes = db_controller.get_storage_nodes()
+def _get_next_3_nodes(cluster_id, lvol_size=0):
+    snodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
     online_nodes = []
     node_stats = {}
     for node in snodes:
         if node.status == node.STATUS_ONLINE:
+            # Validate Eligible nodes for adding lvol
+            snode_api = SNodeClient(node.api_endpoint)
+            result, _ = snode_api.info()
+            memory_free = result["memory_details"]["free"]
+            huge_free = result["memory_details"]["huge_free"]
+            total_node_capacity = db_controller.get_snode_size(node.get_id())
+            error = utils.validate_add_lvol_or_snap_on_node(memory_free, huge_free, node.max_lvol, lvol_size,  total_node_capacity, len(node.lvols))
+            if error:
+                logger.warning(error)
+                continue
+
             online_nodes.append(node)
             node_stat_list = db_controller.get_node_stats(node, limit=1000)
             combined_record = utils.sum_records(node_stat_list)
@@ -461,6 +472,7 @@ def validate_aes_xts_keys(key1: str, key2: str) -> Tuple[bool, str]:
 
     return True, ""
 
+
 def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp, use_crypto,
                 distr_vuid, distr_ndcs, distr_npcs,
                 max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes,
@@ -483,12 +495,12 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
     if not pool:
         return False, f"Pool not found: {pool_id_or_name}"
 
-    cl = db_controller.get_clusters()[0]
+    cl = db_controller.get_cluster_by_id(pool.cluster_id)
     if cl.status not in [cl.STATUS_ACTIVE, cl.STATUS_DEGRADED]:
         return False, f"Cluster is not active, status: {cl.status}"
 
     if ha_type == "default":
-        ha_type = cl.ha_type
+        ha_type = "single"
 
     max_rw_iops = max_rw_iops or 0
     max_rw_mbytes = max_rw_mbytes or 0
@@ -502,8 +514,13 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
         logger.error(error)
         return False, error
 
+    cluster_size_prov = 0
+    cluster_size_total = 0
+    for lvol in db_controller.get_lvols(cl.get_id()):
+        cluster_size_prov += lvol.size
+
     dev_count = 0
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(cl.get_id())
     online_nodes = []
     for node in snodes:
         if node.status == node.STATUS_ONLINE:
@@ -511,6 +528,11 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
             for dev in node.nvme_devices:
                 if dev.status == dev.STATUS_ONLINE:
                     dev_count += 1
+                    cluster_size_total += dev.size
+
+    if len(online_nodes) == 0:
+        logger.error("No online Storage nodes found")
+        return False, "No online Storage nodes found"
 
     if dev_count == 0:
         logger.error("No NVMe devices found in the cluster")
@@ -523,19 +545,6 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
         logger.error("Storage nodes are less than 3 in ha cluster")
         return False, "Storage nodes are less than 3 in ha cluster"
 
-    if len(online_nodes) == 0:
-        logger.error("No online Storage nodes found")
-        return False, "No online Storage nodes found"
-
-    cluster_size_prov = 0
-    cluster_size_total = 0
-    for lvol in db_controller.get_lvols():
-        cluster_size_prov += lvol.size
-
-    for dev in db_controller.get_storage_devices():
-        if dev.status == NVMeDevice.STATUS_ONLINE:
-            cluster_size_total += dev.size
-
     cluster_size_prov_util = int(((cluster_size_prov+size) / cluster_size_total) * 100)
 
     if cl.prov_cap_crit and cl.prov_cap_crit < cluster_size_prov_util:
@@ -697,7 +706,9 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
         lvol.lvol_type += ',compress'
         lvol.top_bdev = lvol.comp_bdev
 
-    nodes = _get_next_3_nodes()
+    nodes = _get_next_3_nodes(cl.get_id(), lvol.size)
+    if not nodes:
+        return False, f"No nodes found with enough resources to create the LVol"
 
     if host_node:
         nodes.insert(0, host_node)
@@ -761,6 +772,7 @@ def _create_bdev_stack(lvol, snode, ha_comm_addrs, ha_inode_self):
             params['jm_names'] = get_jm_names(snode)
             params['ha_comm_addrs'] = ha_comm_addrs
             params['ha_inode_self'] = ha_inode_self
+            params['dev_cpu_mask'] = snode.dev_cpu_mask
             ret = rpc_client.bdev_distrib_create(**params)
             if ret:
                 ret = distr_controller.send_cluster_map_to_node(snode)
@@ -799,6 +811,18 @@ def add_lvol_on_node(lvol, snode, ha_comm_addrs=None, ha_inode_self=None):
     rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
     spdk_mem_info_before = rpc_client.ultra21_util_get_malloc_stats()
 
+    # Validate adding lvol on storage node
+    snode_api = SNodeClient(snode.api_endpoint)
+    result, _ = snode_api.info()
+    memory_free = result["memory_details"]["free"]
+    huge_free = result["memory_details"]["huge_free"]
+
+    total_node_capacity = db_controller.get_snode_size(snode.get_id())
+    error = utils.validate_add_lvol_or_snap_on_node(memory_free, huge_free, snode.max_lvol, lvol.size,  total_node_capacity, len(snode.lvols))
+    if error:
+        logger.error(error)
+        return False, f"Failed to add lvol on node {snode.get_id()}"
+
     ret, msg = _create_bdev_stack(lvol, snode, ha_comm_addrs, ha_inode_self)
     if not ret:
         return False, msg
@@ -930,7 +954,7 @@ def delete_lvol_from_node(lvol_id, node_id, clear_data=True):
     # 3- clear alceml devices
     if clear_data:
         logger.info(f"Clearing Alceml devices")
-        for node in db_controller.get_storage_nodes():
+        for node in db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id):
             if node.status == StorageNode.STATUS_ONLINE:
                 rpc_node = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password)
                 for dev in node.nvme_devices:
@@ -941,11 +965,7 @@ def delete_lvol_from_node(lvol_id, node_id, clear_data=True):
         lvol.write_to_db(db_controller.kv_store)
 
         # 4- clear JM
-        jm_device = None
-        for dev in snode.nvme_devices:
-            if dev.status == NVMeDevice.STATUS_JM:
-                jm_device = dev
-                break
+        jm_device = snode.jm_device
         ret = rpc_client.alceml_unmap_vuid(jm_device.alceml_bdev, lvol.vuid)
         if not ret:
             logger.error(f"Failed to unmap jm alceml {jm_device.alceml_bdev} with vuid {lvol.vuid}")
@@ -1021,7 +1041,7 @@ def delete_lvol(id_or_name, force_delete=False):
         snap = db_controller.get_snapshot_by_id(lvol.cloned_from_snap)
         if snap.deleted is True:
             lvols_count = 0
-            for lvol in db_controller.get_lvols():
+            for lvol in db_controller.get_lvols():  # pass
                 if lvol.cloned_from_snap == snap.get_id():
                     lvols_count += 1
             if lvols_count == 0:
@@ -1082,8 +1102,20 @@ def set_lvol(uuid, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, name=
     return True
 
 
-def list_lvols(is_json):
-    lvols = db_controller.get_lvols()
+def list_lvols(is_json, cluster_id, pool_id_or_name):
+    lvols = []
+    if cluster_id:
+        lvols = db_controller.get_lvols(cluster_id)
+    elif pool_id_or_name:
+        pool = db_controller.get_pool_by_id(pool_id_or_name)
+        if not pool:
+            pool = db_controller.get_pool_by_name(pool_id_or_name)
+            if pool:
+                for lv_id in pool.lvols:
+                    lvols.append(db_controller.get_lvol_by_id(lv_id))
+    else:
+        lvols = db_controller.get_lvols()
+
     data = []
     for lvol in lvols:
         if lvol.deleted is True:
@@ -1134,7 +1166,7 @@ def list_lvols_mem(is_json, is_csv):
 
 def get_lvol(lvol_id_or_name, is_json):
     lvol = None
-    for lv in db_controller.get_lvols():
+    for lv in db_controller.get_lvols():  # pass
         if lv.get_id() == lvol_id_or_name or lv.lvol_name == lvol_id_or_name:
             lvol = lv
             break
@@ -1348,7 +1380,7 @@ def get_cluster_map(lvol_id):
     if not ret:
         logger.error(f"Failed to get LVol cluster map: {lvol_id}")
         return False
-    logger.info(ret)
+    logger.debug(ret)
     print("*"*100)
     results, is_passed = distr_controller.parse_distr_cluster_map(ret)
     return utils.print_table(results)
@@ -1361,8 +1393,12 @@ def migrate(lvol_id, node_id):
         logger.error(f"lvol not found: {lvol_id}")
         return False
 
-    old_node = lvol.node_id
-    nodes = _get_next_3_nodes()
+    old_node_id = lvol.node_id
+    old_node = db_controller.get_storage_node_by_id(old_node_id)
+    nodes = _get_next_3_nodes(old_node.cluster_id)
+    if not nodes:
+        logger.error(f"No nodes found with enough resources to create the LVol")
+        return False
 
     if node_id:
         nodes[0] = db_controller.get_storage_node_by_id(node_id)
@@ -1396,7 +1432,7 @@ def migrate(lvol_id, node_id):
     host_node.write_to_db(db_controller.kv_store)
     lvol.write_to_db(db_controller.kv_store)
 
-    lvol_events.lvol_migrate(lvol, old_node, lvol.node_id)
+    lvol_events.lvol_migrate(lvol, old_node_id, lvol.node_id)
 
     return True
 

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

@@ -23,7 +23,7 @@ def _generate_string(length):
         string.ascii_letters + string.digits) for _ in range(length))
 
 
-def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, has_secret):
+def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, has_secret, cluster_id):
 
     if not name:
         logger.error("Pool name is empty!")
@@ -34,6 +34,11 @@ def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes,
             logger.error(f"Pool found with the same name: {name}")
             return False
 
+    cluster = db_controller.get_cluster_by_id(cluster_id)
+    if not cluster:
+        logger.error(f"Cluster not found: {cluster_id}")
+        return False
+
     pool_max = pool_max or 0
     lvol_max = lvol_max or 0
     max_rw_iops = max_rw_iops or 0
@@ -46,7 +51,6 @@ def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes,
             logger.error("max_rw_mbytes must be greater than max_w_mbytes and max_r_mbytes")
             return False
 
-    cluster = db_controller.get_clusters()[0]
     logger.info("Adding pool")
     pool = Pool()
     pool.id = str(uuid.uuid4())
@@ -136,8 +140,8 @@ def delete_pool(uuid):
     return True
 
 
-def list_pools(is_json):
-    pools = db_controller.get_pools()
+def list_pools(is_json, cluster_id=None):
+    pools = db_controller.get_pools(cluster_id)
     data = []
     for pool in pools:
         data.append({

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

@@ -13,6 +13,8 @@ from simplyblock_core.models.pool import Pool
 from simplyblock_core.models.snapshot import SnapShot
 from simplyblock_core.models.lvol_model import LVol
 from simplyblock_core.rpc_client import RPCClient
+from simplyblock_core.snode_client import SNodeClient
+
 
 logger = lg.getLogger()
 
@@ -33,6 +35,21 @@ def add(lvol_id, snapshot_name):
     logger.info(f"Creating snapshot: {snapshot_name} from LVol: {lvol.id}")
     snode = db_controller.get_storage_node_by_id(lvol.node_id)
 
+##############################################################################
+    # Validate adding snap on storage node
+    snode_api = SNodeClient(snode.api_endpoint)
+    result, _ = snode_api.info()
+    memory_free = result["memory_details"]["free"]
+    huge_free = result["memory_details"]["huge_free"]
+    total_node_capacity = db_controller.get_snode_size(snode.get_id())
+
+    error = utils.validate_add_lvol_or_snap_on_node(memory_free, huge_free, snode.max_snap, lvol.size, total_node_capacity,
+                                                    len(db_controller.get_snapshots_by_node_id(snode.get_id())))
+
+    if error:
+        logger.error(f"Failed to add snap on node {snode.get_id()}")
+        logger.error(error)
+        return False
 
 ##############################################################################
     snap_count = 0
@@ -49,7 +66,7 @@ def add(lvol_id, snapshot_name):
     ret = rpc_client.bdev_distrib_create(
         base_name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
         lvol.distr_bs, lvol_controller.get_jm_names(snode), lvol.distr_chunk_bs,
-        None, None, lvol.distr_page_size)
+        None, None, lvol.distr_page_size, dev_cpu_mask=snode.dev_cpu_mask)
     if not ret:
         logger.error("Failed to create Distr bdev")
         return False, "Failed to create Distr bdev"
@@ -119,7 +136,12 @@ def delete(snapshot_uuid):
         logger.error(f"Snapshot not found {snapshot_uuid}")
         return False
 
-    for lvol in db_controller.get_lvols():
+    snode = db_controller.get_storage_node_by_id(snap.lvol.node_id)
+    if not snode:
+        logger.error(f"Storage node not found {snap.lvol.node_id}")
+        return False
+
+    for lvol in db_controller.get_lvols(snode.cluster_id):
         if lvol.cloned_from_snap and lvol.cloned_from_snap == snapshot_uuid:
             logger.warning(f"Soft delete snapshot with clones, lvol ID: {lvol.get_id()}")
             snap.deleted = True
@@ -194,6 +216,16 @@ def clone(snapshot_id, clone_name, new_size=0):
                 logger.error(msg)
                 return False, msg
 
+    # Validate cloning snap on storage node
+    snode_api = SNodeClient(snode.api_endpoint)
+    result, _ = snode_api.info()
+    memory_free = result["memory_details"]["free"]
+    huge_free = result["memory_details"]["huge_free"]
+    total_node_capacity = db_controller.get_snode_size(snode.get_id())
+    error = utils.validate_add_lvol_or_snap_on_node(memory_free, huge_free, snode.max_lvol, snap.lvol.size,  total_node_capacity, len(snode.lvols))
+    if error:
+        logger.error(error)
+        return False, f"Failed to add lvol on node {snode.get_id()}"
     lvol = LVol()
     lvol.lvol_name = clone_name
     lvol.size = snap.lvol.size
@@ -227,7 +259,8 @@ def clone(snapshot_id, clone_name, new_size=0):
     name = f"distr_{new_vuid}_1"
     ret = rpc_client.bdev_distrib_create(
         name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
-        lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size)
+        lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size,
+        dev_cpu_mask=snode.dev_cpu_mask)
     if not ret:
         msg="Failed to create Distr bdev"
         logger.error(msg)

sbcli_pre-1.2.7/simplyblock_core/controllers/tasks_controller.py

@@ -0,0 +1,103 @@
+# coding=utf-8
+import logging
+import time
+import uuid
+
+from simplyblock_core import kv_store, constants, utils
+from simplyblock_core.controllers import tasks_events
+from simplyblock_core.models.job_schedule import JobSchedule
+
+logger = logging.getLogger()
+db_controller = kv_store.DBController()
+
+
+def _validate_new_task_node_restart(cluster_id, node_id):
+    tasks = db_controller.get_job_tasks(cluster_id)
+    for task in tasks:
+        if task.function_name == JobSchedule.FN_NODE_RESTART and task.node_id == node_id:
+            if task.status != JobSchedule.STATUS_DONE:
+                logger.info(f"Task found, skip adding new task: {task.get_id()}")
+                return False
+    return True
+
+
+def _validate_new_task_dev_restart(cluster_id, node_id, device_id):
+    tasks = db_controller.get_job_tasks(cluster_id)
+    for task in tasks:
+        if task.function_name == JobSchedule.FN_DEV_RESTART and task.device_id == device_id:
+            if task.status != JobSchedule.STATUS_DONE:
+                logger.info(f"Task found, skip adding new task: {task.get_id()}")
+                return False
+        elif task.function_name == JobSchedule.FN_NODE_RESTART and task.node_id == node_id:
+            if task.status != JobSchedule.STATUS_DONE:
+                logger.info(f"Task found, skip adding new task: {task.get_id()}")
+                return False
+    return True
+
+
+def _add_task(function_name, cluster_id, node_id, device_id):
+
+    if function_name in [JobSchedule.FN_DEV_RESTART, JobSchedule.FN_DEV_MIG]:
+        if not _validate_new_task_dev_restart(cluster_id, node_id, device_id):
+            return False
+    elif function_name == JobSchedule.FN_NODE_RESTART:
+        if not _validate_new_task_node_restart(cluster_id, node_id):
+            return False
+
+    task_obj = JobSchedule()
+    task_obj.uuid = str(uuid.uuid4())
+    task_obj.cluster_id = cluster_id
+    task_obj.node_id = node_id
+    task_obj.device_id = device_id
+    task_obj.date = int(time.time())
+    task_obj.function_name = function_name
+    task_obj.status = JobSchedule.STATUS_NEW
+    task_obj.write_to_db(db_controller.kv_store)
+    tasks_events.task_create(task_obj)
+    return task_obj.uuid
+
+
+def add_device_mig_task(device_id):
+    device = db_controller.get_storage_devices(device_id)
+    return _add_task(JobSchedule.FN_DEV_MIG, device.cluster_id, device.node_id, device.get_id())
+
+
+def add_device_to_auto_restart(device):
+    return _add_task(JobSchedule.FN_DEV_RESTART, device.cluster_id, device.node_id, device.get_id())
+
+
+def add_node_to_auto_restart(node):
+    return _add_task(JobSchedule.FN_NODE_RESTART, node.cluster_id, node.get_id(), "")
+
+
+def list_tasks(cluster_id):
+    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({
+            "Task ID": task.uuid,
+            "Target ID": task.device_id or task.node_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 cancel_task(task_id):
+    task = db_controller.get_task_by_id(task_id)
+    if not task:
+        logger.error("Task not found: %s", task_id)
+        return False
+
+    task.canceled = True
+    task.write_to_db(db_controller.kv_store)
+    tasks_events.task_canceled(task)
+    return True

sbcli_pre-1.2.7/simplyblock_core/controllers/tasks_events.py

@@ -0,0 +1,37 @@
+# coding=utf-8
+import logging
+
+from simplyblock_core.controllers import events_controller as ec
+from simplyblock_core.kv_store import DBController
+
+logger = logging.getLogger()
+db_controller = DBController()
+
+
+def _task_event(task, message, caused_by, event):
+    ec.log_event_cluster(
+        cluster_id=task.cluster_id,
+        domain=ec.DOMAIN_CLUSTER,
+        event=event,
+        db_object=task,
+        caused_by=caused_by,
+        message=message,
+        node_id=task.node_id,
+        status=task.status)
+
+
+def task_create(task, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"task created: {task.uuid}", caused_by, ec.EVENT_OBJ_CREATED)
+
+
+def task_updated(task, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"Task updated: {task.uuid}", caused_by, ec.EVENT_STATUS_CHANGE)
+
+
+def task_status_change(task, new_state, old_status, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"task status changed from: {old_status} to: {new_state}", caused_by, ec.EVENT_STATUS_CHANGE)
+
+
+def task_canceled(task, caused_by=ec.CAUSED_BY_CLI):
+    _task_event(task, f"Task canceled: {task.uuid}", caused_by, ec.EVENT_STATUS_CHANGE)
+

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

@@ -10,8 +10,9 @@ from simplyblock_core.kv_store import DBController
 logger = logging.getLogger()
 
 
-def send_node_status_event(node_id, node_status):
+def send_node_status_event(node, node_status):
     db_controller = DBController()
+    node_id = node.get_id()
     logging.info(f"Sending event updates, node: {node_id}, status: {node_status}")
     node_status_event = {
         "timestamp": datetime.datetime.now().isoformat("T", "seconds") + 'Z',
@@ -20,7 +21,7 @@ def send_node_status_event(node_id, node_status):
         "status": node_status}
     events = {"events": [node_status_event]}
     logger.debug(node_status_event)
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(node.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -29,8 +30,9 @@ def send_node_status_event(node_id, node_status):
         ret = rpc_client.distr_status_events_update(events)
 
 
-def send_dev_status_event(storage_ID, dev_status):
+def send_dev_status_event(device, dev_status):
     db_controller = DBController()
+    storage_ID = device.cluster_device_order
     logging.info(f"Sending event updates, device: {storage_ID}, status: {dev_status}")
     node_status_event = {
         "timestamp": datetime.datetime.now().isoformat("T", "seconds") + 'Z',
@@ -39,7 +41,7 @@ def send_dev_status_event(storage_ID, dev_status):
         "status": dev_status}
     events = {"events": [node_status_event]}
     logger.debug(node_status_event)
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(device.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -52,7 +54,7 @@ def send_dev_status_event(storage_ID, dev_status):
 
 def disconnect_device(device):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(device.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -95,7 +97,9 @@ def get_distr_cluster_map(snodes, target_node):
             dev_map[dev.cluster_device_order] = {
                 "UUID": dev.get_id(),
                 "bdev_name": name,
-                "status": dev.status}
+                "status": dev.status,
+                "physical_label": dev.physical_label
+            }
             dev_w_map.append({
                 "weight": dev_w,
                 "id": dev.cluster_device_order})
@@ -158,7 +162,7 @@ def parse_distr_cluster_map(map_string):
                 "Actual Status": "",
                 "Results": "",
             }
-            sd = db_controller.get_storage_devices(device_id)
+            sd = db_controller.get_storage_device_by_id(device_id)
             if sd:
                 data["Actual Status"] = sd.status
                 if sd.status == status:
@@ -175,7 +179,7 @@ def parse_distr_cluster_map(map_string):
 
 def send_cluster_map_to_node(node):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(node.cluster_id)
     rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password)
     cluster_map_data = get_distr_cluster_map(snodes, node)
     cluster_map_data['UUID_node_target'] = node.get_id()
@@ -189,7 +193,7 @@ def send_cluster_map_to_node(node):
 
 def send_cluster_map_add_node(snode):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes()
+    snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue