sbcli-dev 10.4.4__tar.gz → 10.7.1__tar.gz

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sbcli-dev
-Version: 10.4.4
+Version: 10.7.1
 Summary: CLI for managing SimplyBlock cluster
 Home-page: https://www.simplyblock.io/
 Author: Hamdy

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/sbcli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: sbcli-dev
-Version: 10.4.4
+Version: 10.7.1
 Summary: CLI for managing SimplyBlock cluster
 Home-page: https://www.simplyblock.io/
 Author: Hamdy

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_cli/cli.py

@@ -47,6 +47,7 @@ class CLIWrapper:
         sub_command.add_argument("--max-prov", help='Maximum amount of GB to be provisioned via all storage nodes', dest='max_prov')
         sub_command.add_argument("--number-of-distribs", help='The number of distirbs to be created on the node', dest='number_of_distribs', type=int, default=2)
         sub_command.add_argument("--number-of-devices", help='Number of devices per storage node if it\'s not supported EC2 instance', dest='number_of_devices', type=int)
+        sub_command.add_argument("--size-of-device", help='Size of device per storage node', dest='partition_size')
         sub_command.add_argument("--cpu-mask", help='SPDK app CPU mask, default is all cores found', dest='spdk_cpu_mask')
 
         sub_command.add_argument("--spdk-image", help='SPDK image uri', dest='spdk_image')
@@ -58,7 +59,7 @@ class CLIWrapper:
         sub_command.add_argument("--disable-ha-jm", help='Disable HA JM for distrib creation', action='store_false', dest='enable_ha_jm', default=True)
         sub_command.add_argument("--is-secondary-node", help='add as secondary node', action='store_true', dest='is_secondary_node', default=False)
         sub_command.add_argument("--namespace", help='k8s namespace to deploy on',)
-
+        sub_command.add_argument("--id-device-by-nqn", help='Use device nqn to identify it instead of serial number', action='store_true', dest='id_device_by_nqn', default=False)
 
         # delete storage node
         sub_command = self.add_sub_command(subparser, "delete", 'Delete storage node obj')
@@ -798,6 +799,8 @@ class CLIWrapper:
                     number_of_distribs=number_of_distribs,
                     enable_ha_jm=enable_ha_jm,
                     is_secondary_node=args.is_secondary_node,
+                    id_device_by_nqn=args.id_device_by_nqn,
+                    partition_size=args.partition_size,
                 )
 
                 return out

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/cluster_ops.py

@@ -130,6 +130,10 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
         if c.swarm.attrs and "ID" in c.swarm.attrs:
             logger.info("Docker swarm found, leaving swarm now")
             c.swarm.leave(force=True)
+            try:
+                c.volumes.get("monitoring_grafana_data").remove(force=True)
+            except:
+                pass
             time.sleep(3)
 
         c.swarm.init(DEV_IP)
@@ -160,7 +164,7 @@ 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
     if distr_ndcs == 0 and distr_npcs == 0:
-        c.distr_ndcs = 4
+        c.distr_ndcs = 1
         c.distr_npcs = 1
     else:
         c.distr_ndcs = distr_ndcs
@@ -365,7 +369,7 @@ def cluster_activate(cl_id, force=False, force_lvstore_create=False):
         else:
             ret = storage_node_ops.create_lvstore(snode, cluster.distr_ndcs, cluster.distr_npcs, cluster.distr_bs,
                                               cluster.distr_chunk_bs, cluster.page_size_in_blocks, max_size, snodes)
-        if not ret:
+        if not ret and not force:
             logger.error("Failed to activate cluster")
             set_cluster_status(cl_id, ols_status)
             return False
@@ -377,7 +381,7 @@ def cluster_activate(cl_id, force=False, force_lvstore_create=False):
             continue
 
         ret = storage_node_ops.recreate_lvstore(snode)
-        if not ret:
+        if not ret and not force:
             logger.error("Failed to activate cluster")
             set_cluster_status(cl_id, ols_status)
             return False

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/constants.py

@@ -76,7 +76,7 @@ TASK_EXEC_RETRY_COUNT = 8
 SIMPLY_BLOCK_SPDK_CORE_IMAGE = "simplyblock/spdk-core:v24.05-tag-latest"
 
 
-SIMPLY_BLOCK_SPDK_ULTRA_IMAGE = "simplyblock/spdk:lvolstore-ha-snapshot-latest"
+SIMPLY_BLOCK_SPDK_ULTRA_IMAGE = "simplyblock/spdk:main-latest"
 
 GELF_PORT = 12202
 
@@ -88,7 +88,7 @@ EXTRA_LARGE_POOL_COUNT = 16000
 # EXTRA_LARGE_POOL_COUNT = 0
 EXTRA_HUGE_PAGE_MEMORY = 2147483648
 #EXTRA_SYS_MEMORY = 2147483648
-EXTRA_SYS_MEMORY = 0
+EXTRA_SYS_MEMORY = 0.15
 
 INSTANCE_STORAGE_DATA = {
         'i4i.large': {'number_of_devices': 1, 'size_per_device_gb': 468},
@@ -128,4 +128,5 @@ LVOL_NVME_CONNECT_NR_IO_QUEUES=6
 QPAIR_COUNT=32
 NVME_TIMEOUT_US=20000000
 
-NVMF_MAX_SUBSYSTEMS=50000
+NVMF_MAX_SUBSYSTEMS=50000
+HA_JM_COUNT=3

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/controllers/device_controller.py

@@ -118,64 +118,92 @@ def _def_create_device_stack(device_obj, snode, force=False):
     rpc_client = RPCClient(
         snode.mgmt_ip, snode.rpc_port,
         snode.rpc_username, snode.rpc_password,
-        timeout=600
-    )
+        timeout=600)
+
+    bdev_names = []
+    for dev in rpc_client.get_bdevs():
+        bdev_names.append(dev['name'])
+
     nvme_bdev = device_obj.nvme_bdev
     if snode.enable_test_device:
         test_name = f"{device_obj.nvme_bdev}_test"
-        # create testing bdev
-        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
+        if test_name not in bdev_names:
+            # create testing bdev
+            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
+        else:
+            logger.info(f"bdev already exists {test_name}")
+        device_obj.testing_bdev = test_name
         nvme_bdev = test_name
 
     alceml_id = device_obj.get_id()
     alceml_name = get_alceml_name(alceml_id)
-    logger.info(f"adding {alceml_name}")
 
-    if snode.alceml_cpu_cores:
-        alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
-        ret = rpc_client.bdev_alceml_create(alceml_name, nvme_bdev, alceml_id, pba_init_mode=2,
-                                            alceml_cpu_mask=alceml_cpu_mask)
-        snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
-    else:
-        ret = rpc_client.bdev_alceml_create(alceml_name, nvme_bdev, alceml_id, pba_init_mode=2)
+    if alceml_name not in bdev_names:
+        logger.info(f"adding {alceml_name}")
+        if snode.alceml_cpu_cores:
+            alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+            ret = rpc_client.bdev_alceml_create(alceml_name, nvme_bdev, alceml_id, pba_init_mode=2,
+                                                alceml_cpu_mask=alceml_cpu_mask)
+            snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+        else:
+            ret = rpc_client.bdev_alceml_create(alceml_name, nvme_bdev, alceml_id, pba_init_mode=2)
 
-    if not ret:
-        logger.error(f"Failed to create alceml bdev: {alceml_name}")
-        if not force:
-            return False
+        if not ret:
+            logger.error(f"Failed to create alceml bdev: {alceml_name}")
+            if not force:
+                return False
+    else:
+        logger.info(f"bdev already exists {alceml_name}")
 
     # 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
+    if pt_name not in bdev_names:
+        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
+    else:
+        logger.info(f"bdev already exists {pt_name}")
 
     subsystem_nqn = snode.subsystem + ":dev:" + alceml_id
-    logger.info("Creating subsystem %s", subsystem_nqn)
-    ret = rpc_client.subsystem_create(subsystem_nqn, 'sbcli-cn', alceml_id)
-    IP = None
-    for iface in snode.data_nics:
-        if iface.ip4_address:
-            tr_type = iface.get_transport_type()
-            ret = rpc_client.listeners_create(subsystem_nqn, tr_type, iface.ip4_address, "4420")
-            IP = iface.ip4_address
-            break
-    logger.info(f"Adding {pt_name} to the subsystem")
-    ret = rpc_client.nvmf_subsystem_add_ns(subsystem_nqn, pt_name)
+    namespace_found = False
+    subsys_found = False
+    ret = rpc_client.subsystem_list(subsystem_nqn)
+    if ret :
+        subsys_found = True
+        if ret[0]["namespaces"]:
+            for ns in ret[0]["namespaces"]:
+                if ns['name'] == pt_name:
+                    namespace_found = True
+                    break
+
+    if not subsys_found:
+        logger.info("Creating subsystem %s", subsystem_nqn)
+        ret = rpc_client.subsystem_create(subsystem_nqn, 'sbcli-cn', alceml_id)
+        for iface in snode.data_nics:
+            if iface.ip4_address:
+                tr_type = iface.get_transport_type()
+                ret = rpc_client.listeners_create(subsystem_nqn, tr_type, iface.ip4_address, "4420")
+                device_obj.nvmf_ip = iface.ip4_address
+                break
+    else:
+        logger.info(f"subsystem already exists {subsys_found}")
+
+    if not namespace_found:
+        logger.info(f"Adding {pt_name} to the subsystem")
+        ret = rpc_client.nvmf_subsystem_add_ns(subsystem_nqn, pt_name)
+    else:
+        logger.info(f"bdev already added to subsys {pt_name}")
 
-    if snode.enable_test_device:
-        device_obj.testing_bdev = test_name
     device_obj.alceml_bdev = alceml_name
     device_obj.alceml_name = alceml_name
     device_obj.pt_bdev = pt_name
     device_obj.nvmf_nqn = subsystem_nqn
-    device_obj.nvmf_ip = IP
     device_obj.nvmf_port = 4420
     return True
 
@@ -592,110 +620,109 @@ def add_device(device_id):
             break
 
     logger.info(f"Adding device {device_id}")
-    if snode.num_partitions_per_dev == 0:
-        ret = _def_create_device_stack(device_obj, snode, force=True)
-        if not ret:
-            logger.error("Failed to create device stack")
-            return False
-        dev_order = storage_node_ops.get_next_cluster_device_order(db_controller, snode.cluster_id)
-        device_obj.cluster_device_order = dev_order
-        logger.info("Setting device online")
-        device_obj.status = NVMeDevice.STATUS_ONLINE
-        snode.write_to_db(db_controller.kv_store)
-        device_events.device_create(device_obj)
-
-        logger.info("Make other nodes connect to the node devices")
-        snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
-        for node in snodes:
-            if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
-                continue
-            node.remote_devices = storage_node_ops._connect_to_remote_devs(node, force_conect_restarting_nodes=True)
-            node.write_to_db()
-
-
-        snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
-        for node in snodes:
-            if node.status != StorageNode.STATUS_ONLINE:
-                continue
-            distr_controller.send_cluster_map_add_device(device_obj, node)
-
-        tasks_controller.add_new_device_mig_task(device_id)
-        return device_id
-
-
-    # create partitions
-    partitions = snode.num_partitions_per_dev
-    rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
-    # look for partitions
-    partitioned_devices = storage_node_ops._search_for_partitions(rpc_client, device_obj)
-    logger.debug("partitioned_devices")
-    logger.debug(partitioned_devices)
-    if len(partitioned_devices) == partitions+1:
-        logger.info("Partitioned devices found")
-    else:
-        logger.info(f"Creating partitions for {device_obj.nvme_bdev}")
-        storage_node_ops._create_device_partitions(rpc_client, device_obj, snode, partitions, snode.jm_percent)
-        partitioned_devices = storage_node_ops._search_for_partitions(rpc_client, device_obj)
-        if len(partitioned_devices) == partitions+1:
-            logger.info("Device partitions created")
-        else:
-            logger.error("Failed to create partitions")
-            return False
-
-    jm_part = partitioned_devices.pop(0)
-    new_devices = []
-    dev_order = storage_node_ops.get_next_cluster_device_order(db_controller, snode.cluster_id)
-    for dev in partitioned_devices:
-        new_device = storage_node_ops._create_storage_device_stack(rpc_client, dev, snode, after_restart=False)
-        if not new_device:
-            logger.error("failed to create dev stack")
-            continue
-
-        new_device.cluster_device_order = dev_order
-        dev_order += 1
-        device_events.device_create(new_device)
-        new_devices.append(new_device)
-
-    if new_devices:
-        snode.nvme_devices.remove(device_obj)
-        snode.nvme_devices.extend(new_devices)
-        snode.write_to_db(db_controller.kv_store)
-    else:
-        logger.error("failed to create devices")
+    # if snode.num_partitions_per_dev == 0 or device_obj.is_partition:
+    ret = _def_create_device_stack(device_obj, snode, force=True)
+    if not ret:
+        logger.error("Failed to create device stack")
         return False
-
-    for dev in new_devices:
-        distr_controller.send_cluster_map_add_device(dev, snode)
+    dev_order = storage_node_ops.get_next_cluster_device_order(db_controller, snode.cluster_id)
+    device_obj.cluster_device_order = dev_order
+    logger.info("Setting device online")
+    device_obj.status = NVMeDevice.STATUS_ONLINE
+    snode.write_to_db(db_controller.kv_store)
+    device_events.device_create(device_obj)
 
     logger.info("Make other nodes connect to the node devices")
     snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
     for node in snodes:
         if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
             continue
-        node.remote_devices = storage_node_ops._connect_to_remote_devs(node)
+        node.remote_devices = storage_node_ops._connect_to_remote_devs(node, force_conect_restarting_nodes=True)
         node.write_to_db()
-        for dev in new_devices:
-            distr_controller.send_cluster_map_add_device(dev, node)
-
-    for dev in new_devices:
-        tasks_controller.add_new_device_mig_task(dev.get_id())
 
-    # add to jm raid
-    if snode.jm_device and snode.jm_device.raid_bdev and jm_part:
-        # looking for jm partition
-        jm_dev_part = jm_part.nvme_bdev
-        ret = rpc_client.get_bdevs(jm_dev_part)
-        if ret:
-            logger.info(f"JM part found: {jm_dev_part}")
-            if snode.jm_device.status in [JMDevice.STATUS_UNAVAILABLE, JMDevice.STATUS_REMOVED]:
-                restart_jm_device(snode.jm_device.get_id(), force=True, format_alceml=True)
-
-            if snode.jm_device.status == JMDevice.STATUS_ONLINE and \
-                    jm_dev_part not in snode.jm_device.jm_nvme_bdev_list:
-                remove_jm_device(snode.jm_device.get_id(), force=True)
-                restart_jm_device(snode.jm_device.get_id(), force=True)
-
-    return "Done"
+    snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
+    for node in snodes:
+        if node.status != StorageNode.STATUS_ONLINE:
+            continue
+        distr_controller.send_cluster_map_add_device(device_obj, node)
+
+    tasks_controller.add_new_device_mig_task(device_id)
+    return device_id
+
+    #
+    # # create partitions
+    # partitions = snode.num_partitions_per_dev
+    # rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
+    # # look for partitions
+    # partitioned_devices = storage_node_ops._search_for_partitions(rpc_client, device_obj)
+    # logger.debug("partitioned_devices")
+    # logger.debug(partitioned_devices)
+    # if len(partitioned_devices) == partitions+1:
+    #     logger.info("Partitioned devices found")
+    # else:
+    #     logger.info(f"Creating partitions for {device_obj.nvme_bdev}")
+    #     storage_node_ops._create_device_partitions(rpc_client, device_obj, snode, partitions, snode.jm_percent)
+    #     partitioned_devices = storage_node_ops._search_for_partitions(rpc_client, device_obj)
+    #     if len(partitioned_devices) == partitions+1:
+    #         logger.info("Device partitions created")
+    #     else:
+    #         logger.error("Failed to create partitions")
+    #         return False
+    #
+    # jm_part = partitioned_devices.pop(0)
+    # new_devices = []
+    # dev_order = storage_node_ops.get_next_cluster_device_order(db_controller, snode.cluster_id)
+    # for dev in partitioned_devices:
+    #     new_device = storage_node_ops._create_storage_device_stack(rpc_client, dev, snode, after_restart=False)
+    #     if not new_device:
+    #         logger.error("failed to create dev stack")
+    #         continue
+    #
+    #     new_device.cluster_device_order = dev_order
+    #     dev_order += 1
+    #     device_events.device_create(new_device)
+    #     new_devices.append(new_device)
+    #
+    # if new_devices:
+    #     snode.nvme_devices.remove(device_obj)
+    #     snode.nvme_devices.extend(new_devices)
+    #     snode.write_to_db(db_controller.kv_store)
+    # else:
+    #     logger.error("failed to create devices")
+    #     return False
+    #
+    # for dev in new_devices:
+    #     distr_controller.send_cluster_map_add_device(dev, snode)
+    #
+    # logger.info("Make other nodes connect to the node devices")
+    # snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
+    # for node in snodes:
+    #     if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
+    #         continue
+    #     node.remote_devices = storage_node_ops._connect_to_remote_devs(node)
+    #     node.write_to_db()
+    #     for dev in new_devices:
+    #         distr_controller.send_cluster_map_add_device(dev, node)
+    #
+    # for dev in new_devices:
+    #     tasks_controller.add_new_device_mig_task(dev.get_id())
+    #
+    # # add to jm raid
+    # if snode.jm_device and snode.jm_device.raid_bdev and jm_part:
+    #     # looking for jm partition
+    #     jm_dev_part = jm_part.nvme_bdev
+    #     ret = rpc_client.get_bdevs(jm_dev_part)
+    #     if ret:
+    #         logger.info(f"JM part found: {jm_dev_part}")
+    #         if snode.jm_device.status in [JMDevice.STATUS_UNAVAILABLE, JMDevice.STATUS_REMOVED]:
+    #             restart_jm_device(snode.jm_device.get_id(), force=True, format_alceml=True)
+    #
+    #         if snode.jm_device.status == JMDevice.STATUS_ONLINE and \
+    #                 jm_dev_part not in snode.jm_device.jm_nvme_bdev_list:
+    #             remove_jm_device(snode.jm_device.get_id(), force=True)
+    #             restart_jm_device(snode.jm_device.get_id(), force=True)
+    #
+    # return "Done"
 
 
 def device_set_failed_and_migrated(device_id):
@@ -763,11 +790,6 @@ def remove_jm_device(device_id, force=False):
         logger.error("device not found")
         return False
 
-    if jm_device.status != JMDevice.STATUS_ONLINE:
-        logger.warning("device is not online")
-        if not force:
-            return False
-
     set_jm_device_state(snode.jm_device.get_id(), JMDevice.STATUS_UNAVAILABLE)
 
     if snode.status == StorageNode.STATUS_ONLINE:

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/controllers/health_controller.py

@@ -2,6 +2,7 @@
 
 from simplyblock_core import utils, distr_controller
 from simplyblock_core.db_controller import DBController
+from simplyblock_core.models.cluster import Cluster
 from simplyblock_core.models.nvme_device import NVMeDevice, JMDevice
 from simplyblock_core.models.storage_node import StorageNode
 from simplyblock_core.rpc_client import RPCClient
@@ -115,6 +116,10 @@ def _check_node_lvstore(lvstore_stack, node, auto_fix=False):
     logger.info(f"Checking distr stack on node : {node.get_id()}")
     rpc_client = RPCClient(
         node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=3, retry=1)
+    cluster = db_controller.get_cluster_by_id(node.cluster_id)
+    if cluster.status in [Cluster.STATUS_INACTIVE, Cluster.STATUS_IN_ACTIVATION]:
+        auto_fix = False
+
     distribs_list = []
     raid = None
     bdev_lvstore = None

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/controllers/lvol_controller.py

@@ -1118,6 +1118,8 @@ def resize_lvol(id, new_size):
         logger.error(f"Pool is disabled")
         return False
 
+    new_size = utils.parse_size(new_size)
+
     if lvol.size >= new_size:
         logger.error(f"New size {new_size} must be higher than the original size {lvol.size}")
         return False
@@ -1125,28 +1127,39 @@ def resize_lvol(id, new_size):
     if lvol.max_size < new_size:
         logger.error(f"New size {new_size} must be smaller than the max size {lvol.max_size}")
         return False
-
-    if lvol.cloned_from_snap:
-        logger.error(f"Can not resize clone!")
-        return False
-
-    logger.info(f"Resizing LVol: {lvol.get_id()}, new size: {new_size}")
+    #
+    # if lvol.cloned_from_snap:
+    #     logger.error(f"Can not resize clone!")
+    #     return False
 
     snode = db_controller.get_storage_node_by_id(lvol.node_id)
 
+    logger.info(f"Resizing LVol: {lvol.get_id()} on primary node: {snode.get_id()}")
+    logger.info(f"Current size: {utils.humanbytes(lvol.size)}, new size: {utils.humanbytes(new_size)}")
+
     # creating RPCClient instance
     rpc_client = RPCClient(
-        snode.mgmt_ip,
-        snode.rpc_port,
-        snode.rpc_username,
-        snode.rpc_password)
-
+        snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
+    rpc_client.bdev_lvol_set_leader(True, lvs_name=lvol.lvs_name)
     size_in_mib = int(new_size / (1000*1000))
-    ret = rpc_client.bdev_lvol_resize(lvol.top_bdev, size_in_mib)
+    ret = rpc_client.bdev_lvol_resize(f"{lvol.lvs_name}/{lvol.lvol_bdev}", size_in_mib)
     if not ret:
-        logger.error("Error resizing lvol")
+        logger.error(f"Error resizing lvol on node: {snode.get_id()}")
         return False
 
+    if lvol.ha_type == "ha":
+        sec_node = db_controller.get_storage_node_by_id(snode.secondary_node_id)
+        if sec_node and sec_node.status == StorageNode.STATUS_ONLINE:
+            sec_node_rpc_client = RPCClient(
+                sec_node.mgmt_ip, sec_node.rpc_port, sec_node.rpc_username, sec_node.rpc_password)
+            time.sleep(3)
+            logger.info(f"Resizing LVol: {lvol.get_id()} on secondary node: {sec_node.get_id()}")
+            sec_node_rpc_client.bdev_lvol_set_leader(False, lvs_name=lvol.lvs_name)
+            ret = sec_node_rpc_client.bdev_lvol_resize(f"{lvol.lvs_name}/{lvol.lvol_bdev}", size_in_mib)
+            if not ret:
+                logger.error(f"Error resizing lvol on node: {sec_node.get_id()}")
+
+    lvol = db_controller.get_lvol_by_id(id)
     lvol.size = new_size
     lvol.write_to_db(db_controller.kv_store)
     logger.info("Done")

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=10.4.4
+SIMPLY_BLOCK_VERSION=10.7.1
 
 SIMPLY_BLOCK_DOCKER_IMAGE=simplyblock/simplyblock:main
 DOCKER_USER=hamdysimplyblock

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/mgmt_node_ops.py

@@ -132,9 +132,6 @@ def deploy_mgmt_node(cluster_ip, cluster_id, ifname, cluster_secret):
         logger.info("Configuring Double DB...")
         time.sleep(3)
         scripts.set_db_config_double()
-        for cl in db_controller.get_clusters():
-            cl.ha_type = "ha"
-            cl.write_to_db(db_controller.kv_store)
 
     logger.info("Node joined the cluster")
     return node_id

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/models/nvme_device.py

@@ -31,7 +31,7 @@ class NVMeDevice(BaseModel):
     alceml_name: str = ""
     bdev_stack: List = []
     capacity: int = -1
-    cluster_device_order: int = 0
+    cluster_device_order: int = -1
     cluster_id: str = ""
     device_name: str = ""
     health_check: bool = True

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/models/storage_node.py

@@ -35,6 +35,7 @@ class StorageNode(BaseNodeObject):
     hostname: str = ""
     hugepages: int = 0
     ib_devices: List[IFace] = []
+    id_device_by_nqn: bool = False
     iobuf_large_bufsize: int = 0
     iobuf_large_pool_count: int = 0
     iobuf_small_bufsize: int = 0
@@ -79,5 +80,6 @@ class StorageNode(BaseNodeObject):
     spdk_debug: bool = False
     spdk_image: str = ""
     spdk_mem: int = 0
+    partition_size: int = 0
     subsystem: str = ""
     system_uuid: str = ""

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/scripts/config_docker.sh

@@ -6,6 +6,19 @@ function set_config() {
 
 DEV_IP=$1
 
+if [ ! -s "/etc/docker/daemon.json" ]
+then
+  echo '{
+  "log-driver": "json-file",
+  "log-opts": {
+    "max-size": "30m",
+    "max-file": "3"
+  }
+}
+' > /etc/docker/daemon.json
+fi
+
+
 if [[ -z $(grep "tcp://${DEV_IP}:2375" /usr/lib/systemd/system/docker.service) ]]
 then
   set_config ExecStart "/usr/bin/dockerd --containerd=/run/containerd/containerd.sock -H tcp://${DEV_IP}:2375 -H unix:///var/run/docker.sock -H fd://" /usr/lib/systemd/system/docker.service

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/scripts/install_deps.sh

@@ -1,5 +1,10 @@
 #!/usr/bin/env bash
 
+if [[ -z $(grep "$(hostname)" /etc/hosts) ]]
+then
+  sudo sh -c 'echo "127.0.0.1   $(hostname)" >> /etc/hosts'
+fi
+
 sudo yum install -y yum-utils xorg-x11-xauth nvme-cli fio
 sudo yum-config-manager --add-repo https://download.docker.com/linux/centos/docker-ce.repo
 sudo yum install hostname pkg-config git wget python3-pip yum-utils docker-ce docker-ce-cli \

{sbcli_dev-10.4.4 → sbcli_dev-10.7.1}/simplyblock_core/services/health_check_service.py

@@ -4,6 +4,7 @@ from datetime import datetime
 
 
 from simplyblock_core.controllers import health_controller, storage_events, device_events
+from simplyblock_core.models.cluster import Cluster
 from simplyblock_core.models.nvme_device import NVMeDevice
 from simplyblock_core.models.storage_node import StorageNode
 from simplyblock_core.rpc_client import RPCClient
@@ -193,6 +194,8 @@ while True:
                         else:
                             logger.info(f"Checking bdev: {remote_device.remote_bdev} ... not found")
 
+                            if cluster.status in [Cluster.STATUS_IN_ACTIVATION, Cluster.STATUS_INACTIVE]:
+                                continue
                             org_dev = None
                             org_dev_node = None
                             for node in db_controller.get_storage_nodes():