sbcli-hmdi 0.0.23__tar.gz → 0.0.24__tar.gz

{sbcli_hmdi-0.0.23 → sbcli_hmdi-0.0.24}/PKG-INFO

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

{sbcli_hmdi-0.0.23 → sbcli_hmdi-0.0.24}/sbcli_hmdi.egg-info/PKG-INFO

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

{sbcli_hmdi-0.0.23 → sbcli_hmdi-0.0.24}/simplyblock_core/controllers/lvol_controller.py

@@ -463,7 +463,7 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
         }
     }
 
-    if lvol.lvol_priority_class:
+    if cl.enable_qos and lvol.lvol_priority_class >= 0:
         lvol_dict["params"]["lvol_priority_class"] = lvol.lvol_priority_class
     lvol.bdev_stack = [lvol_dict]
 
@@ -659,20 +659,20 @@ def recreate_lvol_on_node(lvol, snode, ha_inode_self=0, ana_state=None):
     rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
 
     base=f"{lvol.lvs_name}/{lvol.lvol_bdev}"
-    retry = 3
-    while retry > 0:
-        lv = rpc_client.get_bdevs(base)
-        if lv:
-            break
-        else:
-            retry -= 1
-            msg = f"LVol bdev not found: {base} on node {snode.get_id()}, retrying"
-            logger.warning(msg)
-            time.sleep(2)
-    else:
-        msg = f"LVol bdev not found: {base} on node {snode.get_id()}"
-        logger.error(msg)
-        return False, msg
+    # retry = 3
+    # while retry > 0:
+    #     lv = rpc_client.get_bdevs(base)
+    #     if lv:
+    #         break
+    #     else:
+    #         retry -= 1
+    #         msg = f"LVol bdev not found: {base} on node {snode.get_id()}, retrying"
+    #         logger.warning(msg)
+    #         time.sleep(2)
+    # else:
+    #     msg = f"LVol bdev not found: {base} on node {snode.get_id()}"
+    #     logger.error(msg)
+    #     return False, msg
 
     if "crypto" in lvol.lvol_type:
         ret = _create_crypto_lvol(
@@ -682,27 +682,27 @@ def recreate_lvol_on_node(lvol, snode, ha_inode_self=0, ana_state=None):
             logger.error(msg)
             return False, msg
 
-    namespace_found = False
-    subsys_found = False
-    ret = rpc_client.subsystem_list(lvol.nqn)
-    if ret :
-        subsys_found = True
-        if ret[0]["namespaces"]:
-            for ns in ret[0]["namespaces"]:
-                if ns['name'] == lvol.top_bdev:
-                    namespace_found = True
-                    break
-
-    if subsys_found is False:
-        min_cntlid = 1 + 1000 * ha_inode_self
-        logger.info("creating subsystem %s", lvol.nqn)
-        rpc_client.subsystem_create(lvol.nqn, 'sbcli-cn', lvol.uuid, min_cntlid)
+    # namespace_found = False
+    # subsys_found = False
+    # ret = rpc_client.subsystem_list(lvol.nqn)
+    # if ret :
+    #     subsys_found = True
+    #     if ret[0]["namespaces"]:
+    #         for ns in ret[0]["namespaces"]:
+    #             if ns['name'] == lvol.top_bdev:
+    #                 namespace_found = True
+    #                 break
+
+    # if subsys_found is False:
+    min_cntlid = 1 + 1000 * ha_inode_self
+    logger.info("creating subsystem %s", lvol.nqn)
+    rpc_client.subsystem_create(lvol.nqn, 'sbcli-cn', lvol.uuid, min_cntlid)
 
-    if namespace_found is False:
-        logger.info("Add BDev to subsystem")
-        ret = rpc_client.nvmf_subsystem_add_ns(lvol.nqn, lvol.top_bdev, lvol.uuid, lvol.guid)
-        if not ret:
-            return False, "Failed to add bdev to subsystem"
+    # if namespace_found is False:
+    logger.info("Add BDev to subsystem")
+    ret = rpc_client.nvmf_subsystem_add_ns(lvol.nqn, lvol.top_bdev, lvol.uuid, lvol.guid)
+    # if not ret:
+    #     return False, "Failed to add bdev to subsystem"
 
     # add listeners
     logger.info("adding listeners")

{sbcli_hmdi-0.0.23 → sbcli_hmdi-0.0.24}/simplyblock_core/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-hmdi
-SIMPLY_BLOCK_VERSION=0.0.23
+SIMPLY_BLOCK_VERSION=0.0.24
 
 SIMPLY_BLOCK_DOCKER_IMAGE=public.ecr.aws/simply-block/simplyblock:hmdi
 DOCKER_USER=hamdysimplyblock

{sbcli_hmdi-0.0.23 → sbcli_hmdi-0.0.24}/simplyblock_core/rpc_client.py

@@ -775,14 +775,9 @@ class RPCClient:
 
     def sock_impl_set_options(self):
         method = "sock_impl_set_options"
-        params = {
-            "impl_name": "posix",
-            "enable_quickack": True,
-            "enable_zerocopy_send_server": False,
-            "enable_zerocopy_send_client": True,
-            "recv_buf_size": 6097152,
-            "send_buf_size": 6097152
-        }
+        params = {"impl_name": "posix", "enable_quickack": True,
+                  "enable_zerocopy_send_server": True,
+                  "enable_zerocopy_send_client": True}
         return self._request(method, params)
 
     def nvmf_set_config(self, poll_groups_mask):
@@ -914,15 +909,17 @@ class RPCClient:
             params = {"jm_vuid": jm_vuid}
         return self._request("bdev_distrib_force_to_non_leader", params)
 
-    def bdev_lvol_set_leader(self, is_leader=False, uuid=None, lvs_name=None):
+    def bdev_lvol_set_leader(self, is_leader=False, uuid=None, lvs_name=None, bs_nonleadership=False):
         params = {
-            "leadership": is_leader,
+            "lvs_leadership": is_leader,
         }
         if uuid:
             params["uuid"] = uuid
         elif lvs_name:
             params["lvs_name"] = lvs_name
 
+        params["bs_nonleadership"] = bs_nonleadership
+
         return self._request("bdev_lvol_set_leader_all", params)
 
     def bdev_lvol_register(self, name, lvs_name, registered_uuid, blobid, priority_class=0):

{sbcli_hmdi-0.0.23 → sbcli_hmdi-0.0.24}/simplyblock_core/storage_node_ops.py

@@ -2866,7 +2866,46 @@ def recreate_lvstore(snode):
     if snode.is_secondary_node:
         return recreate_lvstore_on_sec(snode)
 
+    # connecting to remote devices
+    logger.info("Connecting to remote devices")
+    snode = db_controller.get_storage_node_by_id(snode.get_id())
+    snode.remote_devices = _connect_to_remote_devs(snode)
+    if snode.enable_ha_jm:
+        online_devs = []
+        for remote_device in snode.remote_jm_devices:
+            if remote_device.status == StorageNode.STATUS_ONLINE:
+                online_devs.append(remote_device)
+
+        if len(online_devs) < 2:
+            devs = get_sorted_ha_jms(snode)
+            for did in devs:
+                dev = db_controller.get_jm_device_by_id(did)
+                online_devs.append(dev)
+                if len(online_devs) > snode.ha_jm_count - 1:
+                    break
+
+        snode.remote_jm_devices = online_devs
+        snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
+    snode.write_to_db()
+
+    time.sleep(1)
+
+    ret, err = _create_bdev_stack(snode, [], primary_node=snode)
+
+    if err:
+        logger.error(f"Failed to recreate lvstore on node {snode.get_id()}")
+        logger.error(err)
+        return False
+
+    # ret = rpc_client.bdev_examine(snode.raid)
+    # ret = rpc_client.bdev_wait_for_examine()
+    # ret = rpc_client.bdev_lvol_set_lvs_groupid(snode.lvstore, snode.jm_vuid)
+    # time.sleep(1)
+
+
     sec_node = db_controller.get_storage_node_by_id(snode.secondary_node_id)
+    sec_node_api = SNodeClient(sec_node.api_endpoint)
+
     prim_node_suspend = False
     lvol_list = db_controller.get_lvols_by_node_id(snode.get_id())
     if sec_node:
@@ -2882,60 +2921,64 @@ def recreate_lvstore(snode):
             #                 ret = sec_rpc_client.nvmf_subsystem_listener_set_ana_state(
             #                     lvol.nqn, iface.ip4_address, lvol.subsys_port, False, "inaccessible")
 
-            sec_node_api = SNodeClient(sec_node.api_endpoint)
             sec_node_api.firewall_set_port(snode.lvol_subsys_port, "tcp", "block")
 
-            sec_rpc_client.bdev_lvol_set_leader(False, lvs_name=snode.lvstore)
+            sec_rpc_client.bdev_lvol_set_leader(False, lvs_name=snode.lvstore, bs_nonleadership=True)
             sec_rpc_client.bdev_distrib_force_to_non_leader(snode.jm_vuid)
 
     rpc_client = RPCClient(
         snode.mgmt_ip, snode.rpc_port,
         snode.rpc_username, snode.rpc_password, retry=1, timeout=30)
 
-    # connecting to remote devices
-    logger.info("Connecting to remote devices")
-    snode = db_controller.get_storage_node_by_id(snode.get_id())
-    snode.remote_devices = _connect_to_remote_devs(snode)
-    if snode.enable_ha_jm:
-        # online_devs = []
-        # for remote_device in snode.remote_jm_devices:
-        #     if remote_device.status == StorageNode.STATUS_ONLINE:
-        #         online_devs.append(remote_device)
-        #
-        # if len(online_devs) < 2:
-        #     devs = get_sorted_ha_jms(snode)
-        #     for did in devs:
-        #         dev = db_controller.get_jm_device_by_id(did)
-        #         online_devs.append(dev)
-        #         if len(online_devs) > snode.ha_jm_count - 1:
-        #             break
-        #
-        # snode.remote_jm_devices = online_devs
-        snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
-    snode.write_to_db()
-
-    time.sleep(2)
+    ret = rpc_client.bdev_examine(snode.raid)
+    ret = rpc_client.bdev_wait_for_examine()
+    ret = rpc_client.bdev_lvol_set_lvs_ops(snode.lvstore, snode.jm_vuid, snode.lvol_subsys_port)
+    # time.sleep(1)
+
+    # # connecting to remote devices
+    # logger.info("Connecting to remote devices")
+    # snode = db_controller.get_storage_node_by_id(snode.get_id())
+    # snode.remote_devices = _connect_to_remote_devs(snode)
+    # if snode.enable_ha_jm:
+    #     # online_devs = []
+    #     # for remote_device in snode.remote_jm_devices:
+    #     #     if remote_device.status == StorageNode.STATUS_ONLINE:
+    #     #         online_devs.append(remote_device)
+    #     #
+    #     # if len(online_devs) < 2:
+    #     #     devs = get_sorted_ha_jms(snode)
+    #     #     for did in devs:
+    #     #         dev = db_controller.get_jm_device_by_id(did)
+    #     #         online_devs.append(dev)
+    #     #         if len(online_devs) > snode.ha_jm_count - 1:
+    #     #             break
+    #     #
+    #     # snode.remote_jm_devices = online_devs
+    #     snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
+    # snode.write_to_db()
+    #
+    # time.sleep(2)
 
     if not lvol_list:
         prim_node_suspend = False
 
-    ret, err = _create_bdev_stack(snode, [], primary_node=snode)
-
-    if err:
-        logger.error(f"Failed to recreate lvstore on node {snode.get_id()}")
-        logger.error(err)
-        return False
-
-    ret = rpc_client.bdev_examine(snode.raid)
-    ret = rpc_client.bdev_wait_for_examine()
-    time.sleep(1)
-
-    ret = rpc_client.bdev_lvol_set_lvs_ops(snode.lvstore, snode.jm_vuid, snode.lvol_subsys_port)
+    # ret, err = _create_bdev_stack(snode, [], primary_node=snode)
+    #
+    # if err:
+    #     logger.error(f"Failed to recreate lvstore on node {snode.get_id()}")
+    #     logger.error(err)
+    #     return False
+    #
+    # ret = rpc_client.bdev_examine(snode.raid)
+    # ret = rpc_client.bdev_wait_for_examine()
+    # time.sleep(1)
+    #
+    # ret = rpc_client.bdev_lvol_set_lvs_ops(snode.lvstore, snode.jm_vuid, snode.lvol_subsys_port)
 
-    # if not prim_node_suspend:
-    #     if snode.jm_vuid:
-    #         ret = rpc_client.jc_explicit_synchronization(snode.jm_vuid)
-    #         logger.info(f"JM Sync res: {ret}")
+    if not prim_node_suspend:
+        if snode.jm_vuid:
+            ret = rpc_client.jc_explicit_synchronization(snode.jm_vuid)
+            logger.info(f"JM Sync res: {ret}")
 
     lvol_ana_state = "optimized"
     if prim_node_suspend:
@@ -2953,13 +2996,14 @@ def recreate_lvstore(snode):
             lvol_obj.health_check = True
         lvol_obj.write_to_db()
 
-    if snode.jm_vuid:
-        ret = rpc_client.jc_explicit_synchronization(snode.jm_vuid)
-        logger.info(f"JM Sync res: {ret}")
+    # if snode.jm_vuid:
+    #     ret = rpc_client.jc_explicit_synchronization(snode.jm_vuid)
+    #     logger.info(f"JM Sync res: {ret}")
 
-    sec_node_api = SNodeClient(sec_node.api_endpoint)
     if prim_node_suspend:
-        sec_node_api.firewall_set_port(snode.lvol_subsys_port, "tcp", "allow")
+        if sec_node.status == StorageNode.STATUS_ONLINE:
+            sec_node_api.firewall_set_port(snode.lvol_subsys_port, "tcp", "allow")
+
         set_node_status(snode.get_id(), StorageNode.STATUS_SUSPENDED)
         logger.info("Node restart interrupted because secondary node is unreachable")
         logger.info("Node status changed to suspended")