sbcli-dev 4.0.21__zip → 4.0.23__zip

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/PKG-INFO

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

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/env_var

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

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_core/controllers/device_controller.py

@@ -171,14 +171,6 @@ 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,
-                                        jm_cpu_mask=snode.jm_cpu_mask)
-        if not ret:
-            logger.error(f"Failed to create jm bdev: {device_obj.jm_bdev}")
-            if not force:
-                return False
-
     if snode.enable_test_device:
         device_obj.testing_bdev = test_name
     device_obj.alceml_bdev = alceml_name
@@ -820,29 +812,98 @@ def restart_jm_device(device_id, force=False, format_alceml=False):
             return False
 
     # add to jm raid
-    if snode.jm_device and snode.jm_device.raid_bdev:
+    if snode.jm_device:
         rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
-        bdevs_names = [d['name'] for d in rpc_client.get_bdevs()]
-        jm_nvme_bdevs = []
-        for dev in snode.nvme_devices:
-            if dev.status != NVMeDevice.STATUS_ONLINE:
-                continue
-            dev_part = f"{dev.nvme_bdev[:-2]}p1"
-            if dev_part in bdevs_names:
-                if dev_part not in jm_nvme_bdevs:
-                    jm_nvme_bdevs.append(dev_part)
-
-        if len(jm_nvme_bdevs) > 0:
-            new_jm = storage_node_ops._create_jm_stack_on_raid(
-                rpc_client, jm_nvme_bdevs, snode, after_restart=not format_alceml)
-            if not new_jm:
-                logger.error("failed to create jm stack")
+        if snode.jm_device.raid_bdev:
+            bdevs_names = [d['name'] for d in rpc_client.get_bdevs()]
+            jm_nvme_bdevs = []
+            for dev in snode.nvme_devices:
+                if dev.status != NVMeDevice.STATUS_ONLINE:
+                    continue
+                dev_part = f"{dev.nvme_bdev[:-2]}p1"
+                if dev_part in bdevs_names:
+                    if dev_part not in jm_nvme_bdevs:
+                        jm_nvme_bdevs.append(dev_part)
+
+            if len(jm_nvme_bdevs) > 0:
+                new_jm = storage_node_ops._create_jm_stack_on_raid(
+                    rpc_client, jm_nvme_bdevs, snode, after_restart=not format_alceml)
+                if not new_jm:
+                    logger.error("failed to create jm stack")
+                    return False
+
+                else:
+                    snode = db_controller.get_storage_node_by_id(snode.get_id())
+                    snode.jm_device = new_jm
+                    snode.write_to_db(db_controller.kv_store)
+                    set_jm_device_state(snode.jm_device.get_id(), JMDevice.STATUS_ONLINE)
+        else:
+            nvme_bdev = jm_device.nvme_bdev
+            if snode.enable_test_device:
+                ret = rpc_client.bdev_passtest_create(jm_device.testing_bdev, jm_device.nvme_bdev)
+                if not ret:
+                    logger.error(f"Failed to create passtest bdev {jm_device.testing_bdev}")
+                    return False
+                nvme_bdev = jm_device.testing_bdev
+            alceml_cpu_mask = ""
+            alceml_worker_cpu_mask = ""
+
+            if snode.alceml_cpu_cores:
+                alceml_cpu_mask = utils.decimal_to_hex_power_of_2(snode.alceml_cpu_cores[snode.alceml_cpu_index])
+                snode.alceml_cpu_index = (snode.alceml_cpu_index + 1) % len(snode.alceml_cpu_cores)
+
+            if snode.alceml_worker_cpu_cores:
+                alceml_worker_cpu_mask = utils.decimal_to_hex_power_of_2(
+                    snode.alceml_worker_cpu_cores[snode.alceml_worker_cpu_index])
+                snode.alceml_worker_cpu_index = (snode.alceml_worker_cpu_index + 1) % len(snode.alceml_worker_cpu_cores)
+
+            ret = rpc_client.bdev_alceml_create(jm_device.alceml_bdev, nvme_bdev, jm_device.get_id(),
+                                                pba_init_mode=1, alceml_cpu_mask=alceml_cpu_mask,
+                                                alceml_worker_cpu_mask=alceml_worker_cpu_mask)
+
+            if not ret:
+                logger.error(f"Failed to create alceml bdev: {jm_device.alceml_bdev}")
+                return False
+
+            jm_bdev = f"jm_{snode.get_id()}"
+            ret = rpc_client.bdev_jm_create(jm_bdev, jm_device.alceml_bdev, jm_cpu_mask=snode.jm_cpu_mask)
+            if not ret:
+                logger.error(f"Failed to create {jm_bdev}")
                 return False
 
-            else:
-                snode = db_controller.get_storage_node_by_id(snode.get_id())
-                snode.jm_device = new_jm
-                snode.write_to_db(db_controller.kv_store)
+            if snode.enable_ha_jm:
+                # add pass through
+                pt_name = f"{jm_bdev}_PT"
+                ret = rpc_client.bdev_PT_NoExcl_create(pt_name, jm_bdev)
+                if not ret:
+                    logger.error(f"Failed to create pt noexcl bdev: {pt_name}")
+                    return False
+
+                subsystem_nqn = snode.subsystem + ":dev:" + jm_bdev
+                logger.info("creating subsystem %s", subsystem_nqn)
+                ret = rpc_client.subsystem_create(subsystem_nqn, 'sbcli-cn', jm_bdev)
+                IP = None
+                for iface in snode.data_nics:
+                    if iface.ip4_address:
+                        tr_type = iface.get_transport_type()
+                        ret = rpc_client.transport_list()
+                        found = False
+                        if ret:
+                            for ty in ret:
+                                if ty['trtype'] == tr_type:
+                                    found = True
+                        if found is False:
+                            ret = rpc_client.transport_create(tr_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")
+                        IP = iface.ip4_address
+                        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
+
                 set_jm_device_state(snode.jm_device.get_id(), JMDevice.STATUS_ONLINE)
 
     return True

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_core/controllers/lvol_controller.py

@@ -167,7 +167,7 @@ def validate_add_lvol_func(name, size, host_id_or_name, pool_id_or_name,
 
 def _get_next_3_nodes(cluster_id, lvol_size=0):
     snodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
-    # online_nodes = []
+    online_nodes = []
     node_stats = {}
     for node in snodes:
         if node.status == node.STATUS_ONLINE:
@@ -182,7 +182,7 @@ def _get_next_3_nodes(cluster_id, lvol_size=0):
             #     logger.warning(error)
             #     continue
             #
-            # online_nodes.append(node)
+            online_nodes.append(node)
             # node_stat_list = db_controller.get_node_stats(node, limit=1000)
             # combined_record = utils.sum_records(node_stat_list)
             node_st = {
@@ -539,9 +539,11 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
                 return ret, error
         lvol.nodes = nodes_ids
 
+    host_node = db_controller.get_storage_node_by_id(host_node.get_id())
     host_node.lvols.append(lvol.uuid)
     host_node.write_to_db(db_controller.kv_store)
 
+    pool = db_controller.get_pool_by_id(pool.get_id())
     lvol.pool_uuid = pool.id
     pool.lvols.append(lvol.uuid)
     pool.write_to_db(db_controller.kv_store)
@@ -852,11 +854,15 @@ def delete_lvol(id_or_name, force_delete=False):
                 return False
 
     # remove from storage node
+    snode = db_controller.get_storage_node_by_id(lvol.node_id)
+    logger.debug(snode)
+    logger.debug(f"removing lvol: {lvol.get_id()} from node lvol list: {str(snode.lvols)}")
     if lvol.get_id() in snode.lvols:
         snode.lvols.remove(lvol.get_id())
         snode.write_to_db(db_controller.kv_store)
 
     # remove from pool
+    pool = db_controller.get_pool_by_id(lvol.pool_uuid)
     if lvol.get_id() in pool.lvols:
         pool.lvols.remove(lvol.get_id())
         pool.write_to_db(db_controller.kv_store)

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_core/services/storage_node_monitor.py

@@ -106,8 +106,8 @@ def set_node_online(node):
                 device_controller.device_set_online(dev.get_id())
 
         # set jm dev online
-        if snode.jm_device.status == JMDevice.STATUS_UNAVAILABLE:
-            device_controller.set_jm_device_state(snode.jm_device.get_id(), JMDevice.STATUS_ONLINE)
+        if node.jm_device.status == JMDevice.STATUS_UNAVAILABLE:
+            device_controller.set_jm_device_state(node.jm_device.get_id(), JMDevice.STATUS_ONLINE)
 
         # set node online
         storage_node_ops.set_node_status(node.get_id(), StorageNode.STATUS_ONLINE)
@@ -116,7 +116,7 @@ def set_node_online(node):
 def set_node_offline(node):
     if node.status != StorageNode.STATUS_UNREACHABLE:
         # set node unavailable
-        storage_node_ops.set_node_status(snode.get_id(), StorageNode.STATUS_UNREACHABLE)
+        storage_node_ops.set_node_status(node.get_id(), StorageNode.STATUS_UNREACHABLE)
 
         # set devices unavailable
         for dev in node.nvme_devices:
@@ -124,8 +124,8 @@ def set_node_offline(node):
                 device_controller.device_set_unavailable(dev.get_id())
 
         # set jm dev offline
-        if snode.jm_device.status != JMDevice.STATUS_UNAVAILABLE:
-            device_controller.set_jm_device_state(snode.jm_device.get_id(), JMDevice.STATUS_UNAVAILABLE)
+        if node.jm_device.status != JMDevice.STATUS_UNAVAILABLE:
+            device_controller.set_jm_device_state(node.jm_device.get_id(), JMDevice.STATUS_UNAVAILABLE)
 
 
 logger.info("Starting node monitor")

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_core/services/tasks_runner_failed_migration.py

@@ -65,10 +65,7 @@ def task_runner(task):
             task.write_to_db(db_controller.kv_store)
             return False
 
-        task.function_params = {
-            "migration": {
-                "name": distr_name}
-        }
+        task.function_params['migration'] = {"name": distr_name}
         task.write_to_db(db_controller.kv_store)
         time.sleep(3)
 

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_core/storage_node_ops.py

@@ -16,6 +16,7 @@ from simplyblock_core import constants, scripts, distr_controller
 from simplyblock_core import utils
 from simplyblock_core.controllers import lvol_controller, storage_events, snapshot_controller, device_events, \
     device_controller, tasks_controller, health_controller
+from simplyblock_core.controllers.device_controller import set_jm_device_state
 from simplyblock_core.kv_store import DBController, KVStore
 from simplyblock_core import shell_utils
 from simplyblock_core.models.iface import IFace
@@ -743,7 +744,8 @@ def _prepare_cluster_devices_on_restart(snode):
                 logger.error(f"Failed to add: {pt_name} to the subsystem: {subsystem_nqn}")
                 return False
 
-    return True
+        set_jm_device_state(snode.jm_device.get_id(), JMDevice.STATUS_ONLINE)
+        return True
 
 
 def _connect_to_remote_devs(this_node):

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_web/auth_middleware.py

@@ -10,9 +10,6 @@ from simplyblock_core import kv_store
 def token_required(f):
     @wraps(f)
     def decorated(*args, **kwargs):
-        #TODO: added for e2e tests automation
-        if request.method == "GET" and request.path.startswith("/cluster"):
-            return f(*args, **kwargs)
         cluster_id = None
         cluster_secret = None
         if "Authorization" in request.headers:

{sbcli_dev-4.0.21 → sbcli_dev-4.0.23}/simplyblock_web/blueprints/web_api_cluster.py

@@ -55,24 +55,14 @@ def add_cluster():
 @bp.route('/cluster', methods=['GET'], defaults={'uuid': None})
 @bp.route('/cluster/<string:uuid>', methods=['GET'])
 def list_clusters(uuid):
-    clusters_list = []
-    if uuid:
-        cl = db_controller.get_cluster_by_id(uuid)
-        if cl:
-            clusters_list.append(cl)
-        else:
-            return utils.get_response_error(f"Cluster not found: {uuid}", 404)
-    else:
-        cls = db_controller.get_clusters()
-        if cls:
-            clusters_list.extend(cls)
-
-    data = []
-    for cluster in clusters_list:
-        d = cluster.get_clean_dict()
-        d['status_code'] = cluster.get_status_code()
-        data.append(d)
-    return utils.get_response(data)
+    cluster_id = utils.get_cluster_id(request)
+    cluster = db_controller.get_cluster_by_id(cluster_id)
+    if not cluster:
+        return utils.get_response_error(f"Cluster not found: {cluster_id}", 404)
+
+    d = cluster.get_clean_dict()
+    d['status_code'] = cluster.get_status_code()
+    return utils.get_response(d)
 
 
 @bp.route('/cluster/capacity/<string:uuid>/history/<string:history>', methods=['GET'])