sbcli-pre 1.2.4__zip → 1.2.5__zip

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_core/controllers/device_controller.py

@@ -1,8 +1,8 @@
 import time
 import logging
 
-from simplyblock_core import distr_controller, utils, storage_node_ops
-from simplyblock_core.controllers import device_events, lvol_controller, tasks_controller
+from simplyblock_core import distr_controller, utils
+from simplyblock_core.controllers import device_events, lvol_controller
 from simplyblock_core.kv_store import DBController
 from simplyblock_core.models.nvme_device import NVMeDevice
 from simplyblock_core.rpc_client import RPCClient
@@ -16,7 +16,6 @@ def device_set_state(device_id, state):
     dev = db_controller.get_storage_devices(device_id)
     if not dev:
         logger.error("device not found")
-        return False
 
     snode = db_controller.get_storage_node_by_id(dev.node_id)
     if not snode:
@@ -36,7 +35,7 @@ def device_set_state(device_id, state):
 
     old_status = dev.status
     device.status = state
-    distr_controller.send_dev_status_event(device, device.status)
+    distr_controller.send_dev_status_event(device.cluster_device_order, device.status)
     snode.write_to_db(db_controller.kv_store)
     device_events.device_status_change(device, device.status, old_status)
     return True
@@ -79,20 +78,14 @@ def device_set_read_only(device_id):
 
 
 def device_set_online(device_id):
-    ret = device_set_state(device_id, NVMeDevice.STATUS_ONLINE)
-    if ret:
-        logger.info("Adding task to device data migration")
-        task_id = tasks_controller.add_device_mig_task(device_id)
-        if task_id:
-            logger.info(f"Task id: {task_id}")
-    return ret
+    return device_set_state(device_id, NVMeDevice.STATUS_ONLINE)
 
 
 def get_alceml_name(alceml_id):
     return f"alceml_{alceml_id}"
 
 
-def _def_create_device_stack(device_obj, snode, force=False):
+def _def_create_device_stack(device_obj, snode):
 
     rpc_client = RPCClient(
         snode.mgmt_ip, snode.rpc_port,
@@ -105,26 +98,22 @@ def _def_create_device_stack(device_obj, snode, force=False):
     ret = rpc_client.bdev_passtest_create(test_name, device_obj.nvme_bdev)
     if not ret:
         logger.error(f"Failed to create bdev: {test_name}")
-        if not force:
-            return False
+        return False
 
     alceml_id = device_obj.get_id()
     alceml_name = get_alceml_name(alceml_id)
     logger.info(f"adding {alceml_name}")
-    ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=2,
-                                        dev_cpu_mask=snode.dev_cpu_mask)
+    ret = rpc_client.bdev_alceml_create(alceml_name, test_name, alceml_id, pba_init_mode=2)
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
-        if not force:
-            return False
+        return False
 
     # add pass through
     pt_name = f"{alceml_name}_PT"
     ret = rpc_client.bdev_PT_NoExcl_create(pt_name, alceml_name)
     if not ret:
         logger.error(f"Failed to create pt noexcl bdev: {pt_name}")
-        if not force:
-            return False
+        return False
 
     subsystem_nqn = snode.subsystem + ":dev:" + alceml_id
     logger.info("Creating subsystem %s", subsystem_nqn)
@@ -148,13 +137,11 @@ def _def_create_device_stack(device_obj, snode, force=False):
     logger.info(f"Adding {pt_name} to the subsystem")
     ret = rpc_client.nvmf_subsystem_add_ns(subsystem_nqn, pt_name)
 
-    if hasattr(device_obj, 'jm_bdev') and device_obj.jm_bdev:
-        ret = rpc_client.bdev_jm_create(device_obj.jm_bdev, device_obj.alceml_bdev,
-                                        dev_cpu_mask=snode.dev_cpu_mask)
+    if device_obj.jm_bdev:
+        ret = rpc_client.bdev_jm_create(device_obj.jm_bdev, device_obj.alceml_bdev)
         if not ret:
-            logger.error(f"Failed to create jm bdev: {device_obj.jm_bdev}")
-            if not force:
-                return False
+            logger.error(f"Failed to create bdev: {device_obj.jm_bdev}")
+            return False
 
     device_obj.testing_bdev = test_name
     device_obj.alceml_bdev = alceml_name
@@ -187,15 +174,23 @@ def restart_device(device_id, force=False):
             device_obj = dev
             break
 
+    device_obj.status = 'restarting'
+    snode.write_to_db(db_controller.kv_store)
+
     logger.info(f"Restarting device {device_id}")
-    device_set_unavailable(device_id)
 
-    ret = _def_create_device_stack(device_obj, snode, force=force)
+    ret = _def_create_device_stack(device_obj, snode)
 
     if not ret:
         logger.error("Failed to create device stack")
-        if not force:
-            return False
+        device_obj.status = NVMeDevice.STATUS_UNAVAILABLE
+        snode.write_to_db(db_controller.kv_store)
+        return False
+
+    device_obj.io_error = False
+    device_obj.retries_exhausted = False
+    device_obj.status = NVMeDevice.STATUS_ONLINE
+    snode.write_to_db(db_controller.kv_store)
 
     logger.info("Make other nodes connect to the device")
     snodes = db_controller.get_storage_nodes()
@@ -226,11 +221,10 @@ def restart_device(device_id, force=False):
         node.write_to_db(db_controller.kv_store)
         time.sleep(3)
 
-    logger.info("Setting device io_error to False")
-    device_set_io_error(device_id, False)
-    logger.info("Setting device online")
-    device_set_online(device_id)
+    logger.info("Sending device event")
+    distr_controller.send_dev_status_event(device_obj.cluster_device_order, "online")
     device_events.device_restarted(device_obj)
+
     return "Done"
 
 
@@ -273,8 +267,15 @@ def device_remove(device_id, force=True):
             device = dev
             break
 
+    if device.jm_bdev:
+        if snode.lvols:
+            logger.error(f"Failed to remove device: {device.get_id()}, "
+                         f"there are LVols that uses JM from this device, delete LVol to continue")
+            # if not force:
+            return False
+
     logger.info("Sending device event")
-    distr_controller.send_dev_status_event(device, NVMeDevice.STATUS_REMOVED)
+    distr_controller.send_dev_status_event(device.cluster_device_order, "removed")
 
     logger.info("Disconnecting device from all nodes")
     distr_controller.disconnect_device(device)
@@ -290,6 +291,13 @@ def device_remove(device_id, force=True):
         if not force:
             return False
 
+    if device.jm_bdev:
+        ret = rpc_client.bdev_jm_delete(f"jm_{snode.get_id()}")
+        if not ret:
+            logger.error(f"Failed to remove journal manager: jm_{snode.get_id()}")
+            if not force:
+                return False
+
     logger.info("Removing device bdevs")
     ret = rpc_client.bdev_PT_NoExcl_delete(f"{device.alceml_bdev}_PT")
     if not ret:
@@ -397,12 +405,19 @@ def get_device_iostats(device_id, history, records_count=20, parse_sizes=True):
 
 def reset_storage_device(dev_id):
     db_controller = DBController()
-    device = db_controller.get_storage_devices(dev_id)
+    device = None
+    snode = None
+    for node in db_controller.get_storage_nodes():
+        for dev in node.nvme_devices:
+            if dev.get_id() == dev_id:
+                device = dev
+                snode = node
+                break
+
     if not device:
         logger.error(f"Device not found: {dev_id}")
         return False
 
-    snode = db_controller.get_storage_node_by_id(device.node_id)
     if not snode:
         logger.error(f"Node not found {device.node_id}")
         return False
@@ -411,38 +426,30 @@ def reset_storage_device(dev_id):
         logger.error(f"Device status: {device.status} is removed")
         return False
 
-    logger.info("Setting devices to unavailable")
-    device_set_unavailable(dev_id)
-    devs = []
-    for dev in snode.nvme_devices:
-        if dev.get_id() == device.get_id():
-            continue
-        if dev.status == NVMeDevice.STATUS_ONLINE and dev.physical_label == device.physical_label:
-            devs.append(dev)
-            device_set_unavailable(dev.get_id())
+    logger.info("Setting device to unavailable")
+    old_status = device.status
+    device.status = NVMeDevice.STATUS_UNAVAILABLE
+    distr_controller.send_dev_status_event(device.cluster_device_order, device.status)
+    snode.write_to_db(db_controller.kv_store)
+    device_events.device_status_change(device, device.status, old_status)
 
     logger.info("Resetting device")
     rpc_client = RPCClient(
         snode.mgmt_ip, snode.rpc_port,
         snode.rpc_username, snode.rpc_password)
 
-    controller_name = device.nvme_controller
+    controller_name = device.nvme_bdev[:-2]
     response = rpc_client.reset_device(controller_name)
     if not response:
         logger.error(f"Failed to reset NVMe BDev {controller_name}")
         return False
-    time.sleep(3)
 
-    logger.info("Setting devices online")
-    for dev in devs:
-        device_set_online(dev.get_id())
+    device.io_error = False
+    device.retries_exhausted = False
+    snode.write_to_db(db_controller.kv_store)
 
-    # set io_error flag False
-    device_set_io_error(dev_id, False)
-    device_set_retries_exhausted(dev_id, False)
-    # set device to online
-    device_set_online(dev_id)
     device_events.device_reset(device)
+    device_set_online(dev_id)
     return True
 
 

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_core/controllers/events_controller.py

@@ -40,7 +40,7 @@ def log_distr_event(cluster_id, node_id, event_dict):
     ds.uuid = str(uuid.uuid4())
     ds.cluster_uuid = cluster_id
     ds.node_id = node_id
-    ds.date = round(time.time()*1000)
+    ds.date = int(time.time())
     ds.domain = DOMAIN_DISTR
     ds.event_level = EventObj.LEVEL_ERROR
     ds.caused_by = CAUSED_BY_MONITOR
@@ -66,7 +66,7 @@ def log_distr_event(cluster_id, node_id, event_dict):
 
 
 def log_event_cluster(cluster_id, domain, event, db_object, caused_by, message,
-                      node_id=None, event_level=EventObj.LEVEL_INFO, status=None):
+                      node_id=None, event_level=EventObj.LEVEL_INFO):
     """
     uuid:
     cluster_uuid: 1234
@@ -83,7 +83,7 @@ def log_event_cluster(cluster_id, domain, event, db_object, caused_by, message,
     ds = EventObj()
     ds.uuid = str(uuid.uuid4())
     ds.cluster_uuid = cluster_id
-    ds.date = round(time.time()*1000)
+    ds.date = int(time.time())
     ds.node_id = node_id
     ds.event_level = event_level
 
@@ -93,14 +93,12 @@ def log_event_cluster(cluster_id, domain, event, db_object, caused_by, message,
     ds.object_dict = db_object.get_clean_dict()
     ds.caused_by = caused_by
     ds.message = message
-    ds.status = status
 
     log_event_based_on_level(cluster_id, event, db_object.name, message, caused_by, event_level)
 
     db_controller = DBController()
     ds.write_to_db(db_controller.kv_store)
 
-
 def log_event_based_on_level(cluster_id, event, db_object, message, caused_by, event_level):
     json_str = json.dumps({
         "cluster_id": cluster_id,

{sbcli_pre-1.2.4 → sbcli_pre-1.2.5}/simplyblock_core/controllers/health_controller.py

@@ -16,13 +16,11 @@ logger = log.getLogger()
 
 def check_cluster(cluster_id):
     db_controller = DBController()
-    st = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
+    st = db_controller.get_storage_nodes()
     data = []
-    result = True
     for node in st:
         # check if node is online, unavailable, restarting
         ret = check_node(node.get_id(), with_devices=False)
-        result &= ret
         print("*"*100)
         data.append({
             "Kind": "Node",
@@ -30,32 +28,30 @@ def check_cluster(cluster_id):
             "Status": "ok" if ret else "failed"
         })
 
-        for device in node.nvme_devices:
-            ret = check_device(device.get_id())
-            result &= ret
-            print("*" * 100)
-            data.append({
-                "Kind": "Device",
-                "UUID": device.get_id(),
-                "Status": "ok" if ret else "failed"
-            })
-
-        for lvol in db_controller.get_lvols(cluster_id):
-            ret = check_lvol(lvol.get_id())
-            result &= ret
-            print("*" * 100)
-            data.append({
-                "Kind": "LVol",
-                "UUID": lvol.get_id(),
-                "Status": "ok" if ret else "failed"
-            })
+    for device in db_controller.get_storage_devices():
+        ret = check_device(device.get_id())
+        print("*" * 100)
+        data.append({
+            "Kind": "Device",
+            "UUID": device.get_id(),
+            "Status": "ok" if ret else "failed"
+        })
+
+    for lvol in db_controller.get_lvols():
+        ret = check_lvol(lvol.get_id())
+        print("*" * 100)
+        data.append({
+            "Kind": "LVol",
+            "UUID": lvol.get_id(),
+            "Status": "ok" if ret else "failed"
+        })
     print(utils.print_table(data))
-    return result
+    return True
 
 
 def _check_node_docker_api(ip):
     try:
-        node_docker = docker.DockerClient(base_url=f"tcp://{ip}:2375", version="auto", timeout=3)
+        node_docker = docker.DockerClient(base_url=f"tcp://{ip}:2375", version="auto")
         ret = node_docker.info()
         if ret:
             logger.debug(ret)
@@ -69,7 +65,7 @@ def _check_node_rpc(rpc_ip, rpc_port, rpc_username, rpc_password):
     try:
         rpc_client = RPCClient(
             rpc_ip, rpc_port, rpc_username, rpc_password,
-            timeout=10, retry=1)
+            timeout=5, retry=3)
         ret = rpc_client.get_version()
         if ret:
             logger.debug(f"SPDK version: {ret['version']}")
@@ -171,7 +167,7 @@ def check_node(node_id, with_devices=True):
 
 def check_device(device_id):
     db_controller = DBController()
-    device = db_controller.get_storage_device_by_id(device_id)
+    device = db_controller.get_storage_devices(device_id)
     if not device:
         logger.error("device not found")
         return False
@@ -196,8 +192,8 @@ def check_device(device_id):
             snode.rpc_username, snode.rpc_password)
 
         bdevs_stack = [device.nvme_bdev, device.testing_bdev, device.alceml_bdev, device.pt_bdev]
-        # if device.jm_bdev:
-        #     bdevs_stack.append(device.jm_bdev)
+        if device.jm_bdev:
+            bdevs_stack.append(device.jm_bdev)
         logger.info(f"Checking Device: {device_id}, status:{device.status}")
         problems = 0
         for bdev in bdevs_stack:
@@ -235,7 +231,7 @@ def check_device(device_id):
 
 def check_remote_device(device_id):
     db_controller = DBController()
-    device = db_controller.get_storage_device_by_id(device_id)
+    device = db_controller.get_storage_devices(device_id)
     if not device:
         logger.error("device not found")
         return False
@@ -245,7 +241,7 @@ def check_remote_device(device_id):
         return False
 
     result = True
-    for node in db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id):
+    for node in db_controller.get_storage_nodes():
         if node.status == StorageNode.STATUS_ONLINE:
             if node.get_id() == snode.get_id():
                 continue
@@ -310,6 +306,20 @@ def check_lvol_on_node(lvol_id, node_id):
         logger.exception(e)
         return False
 
+    # check ndcs+npcs <= online devices
+    # then change its status to offline if fails this check
+    online_devices = 0
+    for node in db_controller.get_storage_nodes():
+        for dev in node.nvme_devices:
+            if dev.status == dev.STATUS_ONLINE:
+                online_devices += 1
+
+    # if lvol.ndcs + lvol.npcs < online_devices:
+    #     logger.info(f"Checking Distr ndcs+npcs: {lvol.ndcs}+{lvol.npcs}, online devices: {online_devices} ... ok")
+    # else:
+    #     logger.info(f"Checking Distr ndcs+npcs: {lvol.ndcs}+{lvol.npcs}, online devices: {online_devices} ... failed")
+        # passed = False
+
     return passed
 
 

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

@@ -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(pool.cluster_id):
+    for lvol in db_controller.get_lvols():
         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 [snode.jm_device.jm_bdev] if snode.jm_device else []
+    return [f"jm_{snode.get_id()}"]
 
 
 # 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_by_cluster_id(snode.cluster_id):
+    for node in db_controller.get_storage_nodes():
         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_by_cluster_id(snode.cluster_id):
+            for node in db_controller.get_storage_nodes():
                 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, dev_cpu_mask=snode.dev_cpu_mask)
+                                         distr_chunk_bs)
     bdev_stack.append({"type": "distr", "name": f"distr_{name}"})
     if not ret:
         logger.error("failed to create Distr bdev")
@@ -364,8 +364,8 @@ 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(cluster_id):
-    snodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
+def _get_next_3_nodes():
+    snodes = db_controller.get_storage_nodes()
     online_nodes = []
     node_stats = {}
     for node in snodes:
@@ -461,7 +461,6 @@ 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,
@@ -484,12 +483,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_cluster_by_id(pool.cluster_id)
+    cl = db_controller.get_clusters()[0]
     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 = "single"
+        ha_type = cl.ha_type
 
     max_rw_iops = max_rw_iops or 0
     max_rw_mbytes = max_rw_mbytes or 0
@@ -503,13 +502,8 @@ 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_by_cluster_id(cl.get_id())
+    snodes = db_controller.get_storage_nodes()
     online_nodes = []
     for node in snodes:
         if node.status == node.STATUS_ONLINE:
@@ -517,11 +511,6 @@ 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")
@@ -534,6 +523,19 @@ 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:
@@ -695,9 +697,7 @@ 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(cl.get_id())
-    if not nodes:
-        return False, f"No nodes found with enough resources to create the LVol"
+    nodes = _get_next_3_nodes()
 
     if host_node:
         nodes.insert(0, host_node)
@@ -761,7 +761,6 @@ 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)
@@ -931,7 +930,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_by_cluster_id(snode.cluster_id):
+        for node in db_controller.get_storage_nodes():
             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:
@@ -942,7 +941,11 @@ 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 = snode.jm_device
+        jm_device = None
+        for dev in snode.nvme_devices:
+            if dev.status == NVMeDevice.STATUS_JM:
+                jm_device = dev
+                break
         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}")
@@ -1018,7 +1021,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():  # pass
+            for lvol in db_controller.get_lvols():
                 if lvol.cloned_from_snap == snap.get_id():
                     lvols_count += 1
             if lvols_count == 0:
@@ -1079,20 +1082,8 @@ def set_lvol(uuid, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, name=
     return True
 
 
-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()
-
+def list_lvols(is_json):
+    lvols = db_controller.get_lvols()
     data = []
     for lvol in lvols:
         if lvol.deleted is True:
@@ -1143,7 +1134,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():  # pass
+    for lv in db_controller.get_lvols():
         if lv.get_id() == lvol_id_or_name or lv.lvol_name == lvol_id_or_name:
             lvol = lv
             break
@@ -1357,7 +1348,7 @@ def get_cluster_map(lvol_id):
     if not ret:
         logger.error(f"Failed to get LVol cluster map: {lvol_id}")
         return False
-    logger.debug(ret)
+    logger.info(ret)
     print("*"*100)
     results, is_passed = distr_controller.parse_distr_cluster_map(ret)
     return utils.print_table(results)
@@ -1370,12 +1361,8 @@ def migrate(lvol_id, node_id):
         logger.error(f"lvol not found: {lvol_id}")
         return False
 
-    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
+    old_node = lvol.node_id
+    nodes = _get_next_3_nodes()
 
     if node_id:
         nodes[0] = db_controller.get_storage_node_by_id(node_id)
@@ -1409,7 +1396,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_id, lvol.node_id)
+    lvol_events.lvol_migrate(lvol, old_node, lvol.node_id)
 
     return True