sbcli-dev 3.9.1__zip → 3.9.3__zip

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/PKG-INFO

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

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=3.9.1
+SIMPLY_BLOCK_VERSION=3.9.3
 
 
 SIMPLY_BLOCK_DOCKER_IMAGE=simplyblock/simplyblock:main

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/cluster_ops.py

@@ -170,7 +170,10 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
     c.distr_bs = distr_bs
     c.distr_chunk_bs = distr_chunk_bs
     c.ha_type = ha_type
-    c.grafana_endpoint = grafana_endpoint
+    if grafana_endpoint:
+        c.grafana_endpoint = grafana_endpoint
+    else:
+        c.grafana_endpoint = f"http://{DEV_IP}/grafana"
     c.enable_node_affinity = enable_node_affinity
     
     alerts_template_folder = os.path.join(TOP_DIR, "simplyblock_core/scripts/alerting/")

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/controllers/lvol_controller.py

@@ -165,25 +165,6 @@ def validate_add_lvol_func(name, size, host_id_or_name, pool_id_or_name,
     return True, ""
 
 
-def get_jm_names(snode):
-    return [snode.jm_device.jm_bdev] if snode.jm_device else []
-
-
-def get_ha_jm_names(current_node, snode_list):
-    jm_list = []
-    if current_node.jm_device:
-        jm_list.append(current_node.jm_device.jm_bdev)
-    else:
-        jm_list.append("JM_LOCAL")
-
-    for node in snode_list:
-        if node.get_id() == current_node.get_id():
-            continue
-        name = f"remote_{node.jm_device.jm_bdev}n1"
-        jm_list.append(name)
-    return jm_list[:3]
-
-
 def _get_next_3_nodes(cluster_id, lvol_size=0):
     snodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
     # online_nodes = []
@@ -365,6 +346,11 @@ 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 host_node and host_node.status != StorageNode.STATUS_ONLINE:
+        mgs = f"Storage node is not online. ID: {host_node.get_id()} status: {host_node.status}"
+        logger.error(mgs)
+        return False, mgs
+
     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:

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/distr_controller.py

@@ -27,7 +27,7 @@ def send_node_status_event(node, node_status):
         if node.status != node.STATUS_ONLINE:
             continue
         logger.info(f"Sending to: {node.get_id()}")
-        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=5, retry=1)
+        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=10)
         ret = rpc_client.distr_status_events_update(events)
 
 
@@ -47,7 +47,7 @@ def send_dev_status_event(device, dev_status):
         if node.status != node.STATUS_ONLINE:
             continue
         logger.info(f"Sending to: {node.get_id()}")
-        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=5, retry=1)
+        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=10)
         ret = rpc_client.distr_status_events_update(events)
         if not ret:
             logger.warning("Failed to send event update")
@@ -194,7 +194,7 @@ def parse_distr_cluster_map(map_string):
 def send_cluster_map_to_node(node):
     db_controller = DBController()
     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, timeout=5, retry=1)
+    rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=10)
     cluster_map_data = get_distr_cluster_map(snodes, node)
     cluster_map_data['UUID_node_target'] = node.get_id()
     ret = rpc_client.distr_send_cluster_map(cluster_map_data)
@@ -212,7 +212,7 @@ def send_cluster_map_add_node(snode):
         if node.status != node.STATUS_ONLINE:
             continue
         logger.info(f"Sending to: {node.get_id()}")
-        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=5, retry=1)
+        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=5)
 
         cluster_map_data = get_distr_cluster_map([snode], node)
         cl_map = {

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/kv_store.py

@@ -316,3 +316,9 @@ class DBController:
         for dev in snode.nvme_devices:
             total_node_capacity += dev.size
         return total_node_capacity
+
+    def get_jm_device_by_id(self, jm_id):
+        for node in self.get_storage_nodes():
+            if node.jm_device and node.jm_device.get_id() == jm_id:
+                return node.jm_device
+        return None

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/models/base_model.py

@@ -101,7 +101,10 @@ class BaseModel(object):
             return objects[0]
         return None
 
-    def write_to_db(self, kv_store):
+    def write_to_db(self, kv_store=None):
+        if not kv_store:
+            from simplyblock_core.kv_store import KVStore
+            kv_store = KVStore()
         try:
             prefix = "%s/%s/%s" % (self.object_type, self.name, self.get_id())
             st = json.dumps(self.to_dict())

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/services/health_check_service.py

@@ -55,6 +55,9 @@ while True:
 
             if snode.status not in [StorageNode.STATUS_ONLINE, StorageNode.STATUS_UNREACHABLE]:
                 logger.info(f"Node status is: {snode.status}, skipping")
+                set_node_health_check(snode, False)
+                for dev in snode.nvme_devices:
+                    set_device_health_check(cluster_id, dev, False)
                 continue
 
             # 1- check node ping
@@ -117,7 +120,7 @@ while True:
 
                 if snode.jm_device:
                     jm_device = snode.jm_device
-                    logger.info(f"Node node jm: {jm_device}")
+                    logger.info(f"Node JM: {jm_device}")
                     ret = health_controller.check_jm_device(jm_device.get_id())
                     if ret:
                         logger.info(f"Checking jm bdev: {jm_device.jm_bdev} ... ok")
@@ -133,7 +136,7 @@ while True:
                             logger.info(f"Checking bdev: {remote_device.remote_bdev} ... ok")
                         else:
                             logger.info(f"Checking bdev: {remote_device.remote_bdev} ... not found")
-                        node_remote_devices_check &= bool(ret)
+                        # node_remote_devices_check &= bool(ret)
 
                 lvstore_check = True
                 if snode.lvstore and snode.lvstore_stack:

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_core/storage_node_ops.py

@@ -781,37 +781,45 @@ def _connect_to_remote_devs(this_node):
     return remote_devices
 
 
-def _connect_to_remote_jm_devs(this_node):
+def _connect_to_remote_jm_devs(this_node, jm_ids=[]):
     db_controller = DBController()
 
     rpc_client = RPCClient(
         this_node.mgmt_ip, this_node.rpc_port,
         this_node.rpc_username, this_node.rpc_password, timeout=5, retry=2)
 
+    node_bdevs = rpc_client.get_bdevs()
+    node_bdev_names = [b['name'] for b in node_bdevs]
     remote_devices = []
-    # connect to remote devs
-    snodes = db_controller.get_storage_nodes_by_cluster_id(this_node.cluster_id)
-    for node_index, node in enumerate(snodes):
-        if node.get_id() == this_node.get_id() or node.status != StorageNode.STATUS_ONLINE:
-            continue
-
-        if node.jm_device and node.jm_device.status == NVMeDevice.STATUS_ONLINE:
-            logger.info(f"Connecting to JM on node: {node.get_id()}")
-            name = f"remote_{node.jm_device.jm_bdev}"
-            bdev_name = f"{name}n1"
-            ret = rpc_client.get_bdevs(bdev_name)
+    if jm_ids:
+        for jm_id in jm_ids:
+            jm_dev = db_controller.get_jm_device_by_id(jm_id)
+            remote_devices.append(jm_dev)
+    elif len(this_node.remote_jm_devices) > 0:
+        remote_devices = this_node.remote_jm_devices
+    else:
+        for node in db_controller.get_storage_nodes_by_cluster_id(this_node.cluster_id):
+            if node.get_id() == this_node.get_id() or node.status != StorageNode.STATUS_ONLINE:
+                continue
+            if node.jm_device:
+                remote_devices.append(node.jm_device)
+
+    for jm_dev in remote_devices:
+        name = f"remote_{jm_dev.jm_bdev}"
+        bdev_name = f"{name}n1"
+        jm_dev.remote_bdev = bdev_name
+        if bdev_name in node_bdev_names:
+            logger.info(f"bdev found {bdev_name}")
+            jm_dev.status = JMDevice.STATUS_ONLINE
+        else:
+            logger.info(f"Connecting {this_node.get_id()} to {name}")
+            ret = rpc_client.bdev_nvme_attach_controller_tcp(
+                name, jm_dev.nvmf_nqn, jm_dev.nvmf_ip, jm_dev.nvmf_port)
             if ret:
-                logger.info(f"bdev found {bdev_name}")
+                jm_dev.status = JMDevice.STATUS_ONLINE
             else:
-                logger.info(f"Connecting {this_node.get_id()} to {name}")
-                ret = rpc_client.bdev_nvme_attach_controller_tcp(
-                    name, node.jm_device.nvmf_nqn, node.jm_device.nvmf_ip, node.jm_device.nvmf_port)
-                if not ret:
-                    logger.error(f"failed to connect to remote JM {node.jm_device.jm_bdev}")
-                    continue
-
-            node.jm_device.remote_bdev = bdev_name
-            remote_devices.append(node.jm_device)
+                logger.error(f"failed to connect to remote JM {name}")
+                jm_dev.status = JMDevice.STATUS_UNAVAILABLE
 
     return remote_devices
 
@@ -929,6 +937,9 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     except Exception:
         pass
     max_prov = int(utils.parse_size(max_prov))
+    if max_prov <= 0:
+        logger.error(f"Incorrect max-prov value {max_prov}")
+        return False
     number_of_split = num_partitions_per_dev if num_partitions_per_dev else 1
     number_of_alceml_devices = number_of_devices * number_of_split
     # for jm
@@ -1206,7 +1217,8 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
             else:
                 node.remote_devices.append(dev)
 
-        if node.enable_ha_jm:
+        if snode.jm_device and node.enable_ha_jm:
+            node.remote_jm_devices.append(snode.jm_device)
             node.remote_jm_devices = _connect_to_remote_jm_devs(node)
         node.write_to_db(kv_store)
         logger.info(f"connected to devices count: {len(node.remote_devices)}")
@@ -1445,6 +1457,9 @@ def restart_storage_node(
         except Exception:
             pass
         snode.max_prov = int(utils.parse_size(max_prov))
+    if snode.max_prov <= 0:
+        logger.error(f"Incorrect max-prov value {max_prov}")
+        return False
     if spdk_image:
         snode.spdk_image = spdk_image
 
@@ -2534,28 +2549,32 @@ def recreate_lvstore(snode):
     return True
 
 
-def get_next_ha_jm_names(current_node):
+def get_next_ha_jms(current_node):
     db_controller = DBController(KVStore())
-    jm_list = []
-    if current_node.jm_device:
-        jm_list.append(current_node.jm_device.jm_bdev)
-    else:
-        jm_list.append("JM_LOCAL")
-
     jm_count = {}
     for node in db_controller.get_storage_nodes_by_cluster_id(current_node.cluster_id):
         if node.get_id() == current_node.get_id() or node.status != StorageNode.STATUS_ONLINE:
             continue
         if node.jm_device:
-            jm_count[node.jm_device.jm_bdev] = 1 + jm_count.get(node.jm_device.jm_bdev, 0)
+            jm_count[node.jm_device.get_id()] = 1 + jm_count.get(node.jm_device.get_id(), 0)
         for rem_jm_device in node.remote_jm_devices:
-            jm_count[rem_jm_device.jm_bdev] = 1 + jm_count.get(rem_jm_device.jm_bdev, 0)
+            if rem_jm_device.get_id() != current_node.jm_device.get_id():
+                jm_count[rem_jm_device.get_id()] = 1 + jm_count.get(rem_jm_device.get_id(), 0)
 
     jm_count = dict(sorted(jm_count.items(), key=lambda x: x[1]))
+    return list(jm_count.keys())[:2]
 
-    jm_list.append(f"remote_{list(jm_count.keys())[0].jm_bdev}n1")
-    jm_list.append(f"remote_{list(jm_count.keys())[1].jm_bdev}n1")
 
+def get_node_jm_names(current_node):
+    jm_list = []
+    if current_node.jm_device:
+        jm_list.append(current_node.jm_device.jm_bdev)
+    else:
+        jm_list.append("JM_LOCAL")
+
+    if current_node.enable_ha_jm:
+        for jm_dev in current_node.remote_jm_devices[:2]:
+            jm_list.append(f"remote_{jm_dev.jm_bdev}n1")
     return jm_list
 
 
@@ -2569,13 +2588,10 @@ def create_lvstore(snode, ndcs, npcs, distr_bs, distr_chunk_bs, page_size_in_blo
     strip_size_kb = utils.nearest_upper_power_of_2(strip_size_kb)
     jm_vuid = 0
     if snode.enable_ha_jm:
-        if len(nodes) > 3:
-            nodes = nodes[:3]
-        jm_names = lvol_controller.get_ha_jm_names(snode, nodes)
         jm_vuid = utils.get_random_vuid()
-    else:
-        jm_names = lvol_controller.get_jm_names(snode)
-
+        online_jms = get_next_ha_jms(snode)
+        snode.remote_jm_devices = _connect_to_remote_jm_devs(snode, online_jms)
+        snode.write_to_db()
 
     for _ in range(snode.number_of_distribs):
         distrib_vuid = utils.get_random_vuid()
@@ -2588,7 +2604,6 @@ def create_lvstore(snode, ndcs, npcs, distr_bs, distr_chunk_bs, page_size_in_blo
                     "name": distrib_name,
                     "params": {
                         "name": distrib_name,
-                        "jm_names": jm_names,
                         "jm_vuid": jm_vuid,
                         "vuid": distrib_vuid,
                         "ndcs": ndcs,
@@ -2616,14 +2631,6 @@ def create_lvstore(snode, ndcs, npcs, distr_bs, distr_chunk_bs, page_size_in_blo
                 },
                 "distribs_list": distrib_list
             },
-            # {
-            #     "type": "bdev_ptnonexcl",
-            #     "name": "raid_PT",
-            #     "params": {
-            #         "name": "raid_PT",
-            #         "base_bdev_name": raid_device
-            #     }
-            # },
             {
                 "type": "bdev_lvstore",
                 "name": lvs_name,
@@ -2645,13 +2652,11 @@ def create_lvstore(snode, ndcs, npcs, distr_bs, distr_chunk_bs, page_size_in_blo
         logger.error(err)
         return False
 
-
     snode.lvstore = lvs_name
     snode.lvstore_stack = lvstore_stack
     snode.raid = raid_device
-    db_controller = DBController(KVStore())
-    snode.write_to_db(db_controller.kv_store)
-    time.sleep(3)
+    snode.write_to_db()
+    time.sleep(1)
     return True
 
 
@@ -2671,6 +2676,7 @@ def _create_bdev_stack(snode, lvstore_stack=None):
         params = bdev['params']
 
         if type == "bdev_distr":
+            params['jm_names'] = get_node_jm_names(snode)
             if snode.distrib_cpu_cores:
                 distrib_cpu_mask = utils.decimal_to_hex_power_of_2(snode.distrib_cpu_cores[snode.distrib_cpu_index])
                 params['distrib_cpu_mask'] = distrib_cpu_mask
@@ -2687,26 +2693,6 @@ def _create_bdev_stack(snode, lvstore_stack=None):
 
         elif type == "bdev_ptnonexcl":
             ret = rpc_client.bdev_PT_NoExcl_create(**params)
-            if ret:
-                try:
-                    # add pass through
-                    pt_name = "raid_PT"
-                    subsystem_nqn = snode.subsystem + ":dev:raid"
-                    logger.info("creating raid subsystem %s", subsystem_nqn)
-                    ret = rpc_client.subsystem_create(subsystem_nqn, 'sbcli-cn', 'sbcli-cn')
-                    for iface in snode.data_nics:
-                        if iface.ip4_address:
-                            tr_type = iface.get_transport_type()
-                            logger.info("adding listener for %s on IP %s" % (subsystem_nqn, iface.ip4_address))
-                            ret = rpc_client.listeners_create(subsystem_nqn, tr_type, iface.ip4_address, "4420")
-                            break
-                    logger.info(f"add {pt_name} to subsystem")
-                    ret = rpc_client.nvmf_subsystem_add_ns(subsystem_nqn, pt_name)
-                    if not ret:
-                        logger.error(f"Failed to add: {pt_name} to the subsystem: {subsystem_nqn}")
-                        return False
-                except:
-                    pass
 
         elif type == "bdev_raid":
             distribs_list = bdev["distribs_list"]

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_web/blueprints/web_api_lvol.py

@@ -230,7 +230,7 @@ def resize_lvol(uuid):
 
     cl_data = request.get_json()
     if 'size' not in cl_data:
-        return utils.get_response(None, "missing required param: new_size", 400)
+        return utils.get_response(None, "missing required param: size", 400)
 
     new_size = utils.parse_size(cl_data['size'])
 

{sbcli_dev-3.9.1 → sbcli_dev-3.9.3}/simplyblock_web/blueprints/web_api_storage_node.py

@@ -195,8 +195,8 @@ def storage_node_add():
     max_lvol = int(req_data['max_lvol'])
     max_snap = int(req_data.get('max_snap', 500))
     max_prov = req_data['max_prov']
-    number_of_distribs = req_data.get('number_of_distribs', 4)
-    enable_ha_jm = req_data.get('enable_ha_jm', True)
+    number_of_distribs = int(req_data.get('number_of_distribs', 4))
+    disable_ha_jm = bool(req_data.get('disable_ha_jm', False))
 
     spdk_image = None
     if 'spdk_image' in req_data:
@@ -262,7 +262,7 @@ def storage_node_add():
         "enable_test_device": False,
         "number_of_distribs": number_of_distribs,
         "namespace": namespace,
-        "enable_ha_jm": enable_ha_jm})
+        "enable_ha_jm": not disable_ha_jm})
 
     return utils.get_response(True)