sbcli-dev 18.0.76__tar.gz → 18.0.78__tar.gz

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/PKG-INFO

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

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/simplyblock_core/controllers/device_controller.py

@@ -144,24 +144,13 @@ def _def_create_device_stack(device_obj, snode, force=False):
     alceml_name = get_alceml_name(alceml_id)
 
     cluster = db_controller.get_cluster_by_id(snode.cluster_id)
-    write_protection = False
-    if cluster.distr_ndcs > 1:
-        write_protection = True
     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,
-                pba_page_size=cluster.page_size_in_blocks, write_protection=write_protection,
-                full_page_unmap=snode.full_page_unmap
-            )
-            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, pba_page_size=cluster.page_size_in_blocks,
-                write_protection=write_protection, full_page_unmap=snode.full_page_unmap
-            )
+        ret = snode.create_alceml(
+            alceml_name, nvme_bdev, alceml_id,
+            pba_init_mode=2,
+            write_protection=cluster.distr_ndcs > 1,
+            pba_page_size=cluster.page_size_in_blocks,
+        )
 
         if not ret:
             logger.error(f"Failed to create alceml bdev: {alceml_name}")
@@ -899,23 +888,12 @@ def restart_jm_device(device_id, force=False, format_alceml=False):
             #         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)
-
             cluster = db_controller.get_cluster_by_id(snode.cluster_id)
-            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, pba_page_size=cluster.page_size_in_blocks,
-                full_page_unmap=snode.full_page_unmap
+            ret = snode.create_alceml(
+                jm_device.alceml_bdev, nvme_bdev, jm_device.get_id(),
+                pba_init_mode=1,
+                pba_page_size=cluster.page_size_in_blocks,
             )
 
             if not ret:

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/simplyblock_core/env_var

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

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/simplyblock_core/models/storage_node.py

@@ -258,3 +258,23 @@ class StorageNode(BaseNodeObject):
         if not rpc_client.bdev_lvol_connect_hublvol(primary_node.lvstore, remote_bdev):
             pass
             # raise RPCException('Failed to connect secondary lvstore to primary')
+
+    def create_alceml(self, name, nvme_bdev, uuid, **kwargs):
+        logger.info(f"Adding {name}")
+        alceml_cpu_mask = ""
+        alceml_worker_cpu_mask = ""
+        if self.alceml_cpu_cores:
+            alceml_cpu_mask = utils.decimal_to_hex_power_of_2(self.alceml_cpu_cores[self.alceml_cpu_index])
+            self.alceml_cpu_index = (self.alceml_cpu_index + 1) % len(self.alceml_cpu_cores)
+        if self.alceml_worker_cpu_cores:
+            alceml_worker_cpu_mask = utils.decimal_to_hex_power_of_2(
+                self.alceml_worker_cpu_cores[self.alceml_worker_cpu_index])
+            self.alceml_worker_cpu_index = (self.alceml_worker_cpu_index + 1) % len(self.alceml_worker_cpu_cores)
+
+        return self.rpc_client().bdev_alceml_create(
+            name, nvme_bdev, uuid,
+            alceml_cpu_mask=alceml_cpu_mask,
+            alceml_worker_cpu_mask=alceml_worker_cpu_mask,
+            full_page_unmap=self.full_page_unmap,
+            **kwargs,
+        )

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/simplyblock_core/storage_node_ops.py

@@ -93,25 +93,15 @@ def _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart):
     alceml_id = snode.get_id()
     alceml_name = f"alceml_jm_{snode.get_id()}"
     nvme_bdev = raid_bdev
-    pba_init_mode = 3
-    if after_restart:
-        pba_init_mode = 1
-    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)
 
     db_controller = DBController()
     cluster = db_controller.get_cluster_by_id(snode.cluster_id)
-    ret = rpc_client.bdev_alceml_create(alceml_name, nvme_bdev, alceml_id, pba_init_mode=pba_init_mode,
-                                        alceml_cpu_mask=alceml_cpu_mask, alceml_worker_cpu_mask=alceml_worker_cpu_mask,
-                                        pba_page_size=cluster.page_size_in_blocks,
-                                        full_page_unmap=snode.full_page_unmap)
+    ret = snode.create_alceml(
+        alceml_name, nvme_bdev, alceml_id,
+        pba_init_mode=1 if after_restart else 3,
+        pba_page_size=cluster.page_size_in_blocks,
+    )
+
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
         return False
@@ -173,7 +163,6 @@ def _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart):
 def _create_jm_stack_on_device(rpc_client, nvme, snode, after_restart):
     alceml_id = nvme.get_id()
     alceml_name = device_controller.get_alceml_name(alceml_id)
-    logger.info(f"adding {alceml_name}")
     db_controller = DBController()
     nvme_bdev = nvme.nvme_bdev
     test_name = ""
@@ -184,24 +173,13 @@ def _create_jm_stack_on_device(rpc_client, nvme, snode, after_restart):
             logger.error(f"Failed to create passtest bdev {test_name}")
             return False
         nvme_bdev = test_name
-    pba_init_mode = 3
-    if after_restart:
-        pba_init_mode = 1
-    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)
 
     cluster = db_controller.get_cluster_by_id(snode.cluster_id)
-    ret = rpc_client.bdev_alceml_create(
-        alceml_name, nvme_bdev, alceml_id, pba_init_mode=pba_init_mode, alceml_cpu_mask=alceml_cpu_mask,
-        alceml_worker_cpu_mask=alceml_worker_cpu_mask, pba_page_size=cluster.page_size_in_blocks,
-        full_page_unmap=snode.full_page_unmap)
+    ret = snode.create_alceml(
+        alceml_name, nvme_bdev, alceml_id,
+        pba_init_mode=1 if after_restart else 3,
+        pba_page_size=cluster.page_size_in_blocks,
+    )
 
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
@@ -273,29 +251,16 @@ def _create_storage_device_stack(rpc_client, nvme, snode, after_restart):
         nvme_bdev = test_name
     alceml_id = nvme.get_id()
     alceml_name = device_controller.get_alceml_name(alceml_id)
-    logger.info(f"adding {alceml_name}")
-    pba_init_mode = 3
-    if after_restart and nvme.status != NVMeDevice.STATUS_NEW:
-        pba_init_mode = 1
-    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)
 
     cluster = db_controller.get_cluster_by_id(snode.cluster_id)
-    write_protection = False
-    if cluster.distr_ndcs > 1:
-        write_protection = True
-    ret = rpc_client.bdev_alceml_create(alceml_name, nvme_bdev, alceml_id, pba_init_mode=pba_init_mode,
-                                        alceml_cpu_mask=alceml_cpu_mask, alceml_worker_cpu_mask=alceml_worker_cpu_mask,
-                                        pba_page_size=cluster.page_size_in_blocks, write_protection=write_protection,
-                                        full_page_unmap=snode.full_page_unmap)
+
+    ret = snode.create_alceml(
+        alceml_name, nvme_bdev, alceml_id,
+        pba_init_mode=1 if (after_restart and nvme.status != NVMeDevice.STATUS_NEW) else 3,
+        write_protection=cluster.distr_ndcs > 1,
+        pba_page_size=cluster.page_size_in_blocks,
+    )
+
     if not ret:
         logger.error(f"Failed to create alceml bdev: {alceml_name}")
         return None
@@ -564,25 +529,13 @@ def _prepare_cluster_devices_on_restart(snode, clear_data=False):
                 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)
-
-        pba_init_mode = 3
-        if not clear_data:
-            pba_init_mode = 1
+
         cluster = db_controller.get_cluster_by_id(snode.cluster_id)
-        ret = rpc_client.bdev_alceml_create(
-            jm_device.alceml_bdev, nvme_bdev, jm_device.get_id(), pba_init_mode=pba_init_mode,
-            alceml_cpu_mask=alceml_cpu_mask, alceml_worker_cpu_mask=alceml_worker_cpu_mask,
-            pba_page_size=cluster.page_size_in_blocks, full_page_unmap=snode.full_page_unmap)
+        ret = snode.create_alceml(
+            jm_device.alceml_bdev, nvme_bdev, jm_device.get_id(),
+            pba_init_mode=3 if clear_data else 1,
+            pba_page_size=cluster.page_size_in_blocks,
+        )
 
         if not ret:
             logger.error(f"Failed to create alceml bdev: {jm_device.alceml_bdev}")

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/simplyblock_web/blueprints/snode_ops.py

@@ -251,6 +251,7 @@ def spdk_process_is_up(query: _RPCPortQuery):
     try:
         node_docker = get_docker_client()
         for cont in node_docker.containers.list(all=True):
+            logger.debug(f"Container: {cont.attrs['Name']} status: {cont.attrs['State']}")
             if cont.attrs['Name'] == f"/spdk_{query.rpc_port}":
                 status = cont.attrs['State']["Status"]
                 is_running = cont.attrs['State']["Running"]
@@ -260,7 +261,7 @@ def spdk_process_is_up(query: _RPCPortQuery):
                     return utils.get_response(False, f"SPDK container status: {status}, is running: {is_running}")
     except Exception as e:
         logger.error(e)
-    return utils.get_response(True)
+    return utils.get_response(False, f"container not found: /spdk_{query.rpc_port}")
 
 
 

{sbcli_dev-18.0.76 → sbcli_dev-18.0.78}/simplyblock_web/blueprints/snode_ops_k8s.py

@@ -449,7 +449,7 @@ def get_file_content(path: FilePath):
 
 
 class _FirewallParams(BaseModel):
-    port_id: str
+    port_id: int
     port_type: str
     action: str