sbcli-dev 5.1.3__zip → 5.1.5__zip

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/PKG-INFO

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

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/env_var

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

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_cli/cli.py

@@ -296,6 +296,11 @@ class CLIWrapper:
         sub_command.add_argument("--enable-node-affinity", help='Enable node affinity for storage nodes', action='store_true')
         sub_command.add_argument("--qpair-count", help='tcp transport qpair count', type=int, dest='qpair_count',
                                  default=6, choices=range(128))
+        sub_command.add_argument("--max-queue-size", help='The max size the queue will grow', type=int, default=128)
+        sub_command.add_argument("--inflight-io-threshold", help='The number of inflight IOs allowed before the IO queuing starts', type=int, default=4)
+        sub_command.add_argument("--enable-qos", help='Enable qos bdev for storage nodes', action='store_true', dest='enable_qos')
+
+
         # add cluster
         sub_command = self.add_sub_command(subparser, 'add', 'Add new cluster')
         sub_command.add_argument("--blk_size", help='The block size in bytes', type=int, choices=[512, 4096], default=512)
@@ -319,6 +324,9 @@ class CLIWrapper:
         sub_command.add_argument("--enable-node-affinity", help='Enable node affinity for storage nodes', action='store_true')
         sub_command.add_argument("--qpair-count", help='tcp transport qpair count', type=int, dest='qpair_count',
                                  default=6, choices=range(128))
+        sub_command.add_argument("--max-queue-size", help='The max size the queue will grow', type=int, default=128)
+        sub_command.add_argument("--inflight-io-threshold", help='The number of inflight IOs allowed before the IO queuing starts', type=int, default=4)
+        sub_command.add_argument("--enable-qos", help='Enable qos bdev for storage nodes', action='store_true', dest='enable_qos')
 
         # Activate cluster
         sub_command = self.add_sub_command(subparser, 'activate', 'Create distribs and raid0 bdevs on all the storage node and move the cluster to active state')
@@ -440,6 +448,7 @@ class CLIWrapper:
                                  default=0)
         sub_command.add_argument("--ha-type", help='LVol HA type (single, ha), default is cluster HA type',
                                  dest='ha_type', choices=["single", "ha", "default"], default='default')
+        sub_command.add_argument("--lvol-priority-class", help='Lvol priority class', type=int, choices=[0, 1], default=0)
 
 
         # set lvol params
@@ -1007,6 +1016,7 @@ class CLIWrapper:
                 crypto = args.encrypt
                 distr_vuid = args.distr_vuid
                 with_snapshot = args.snapshot
+                lvol_priority_class = args.lvol_priority_class
                 results, error = lvol_controller.add_lvol_ha(
                     name, size, host_id, ha_type, pool, comp, crypto,
                     distr_vuid,
@@ -1017,7 +1027,8 @@ class CLIWrapper:
                     with_snapshot=with_snapshot,
                     max_size=max_size,
                     crypto_key1=args.crypto_key1,
-                    crypto_key2=args.crypto_key2)
+                    crypto_key2=args.crypto_key2,
+                    lvol_priority_class=lvol_priority_class)
                 if results:
                     ret = results
                 else:
@@ -1252,12 +1263,18 @@ class CLIWrapper:
         distr_bs = args.distr_bs
         distr_chunk_bs = args.distr_chunk_bs
         ha_type = args.ha_type
+
         enable_node_affinity = args.enable_node_affinity
         qpair_count = args.qpair_count
+        max_queue_size = args.max_queue_size
+        inflight_io_threshold = args.inflight_io_threshold
+        enable_qos = args.enable_qos
 
         return cluster_ops.add_cluster(
             blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit,
-            distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity, qpair_count)
+            distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity,
+            qpair_count, max_queue_size, inflight_io_threshold, enable_qos)
+
 
     def cluster_create(self, args):
         page_size_in_blocks = args.page_size
@@ -1279,12 +1296,18 @@ class CLIWrapper:
         grafana_endpoint = args.grafana_endpoint
         enable_node_affinity = args.enable_node_affinity
         qpair_count = args.qpair_count
+        max_queue_size = args.max_queue_size
+        inflight_io_threshold = args.inflight_io_threshold
+        enable_qos = args.enable_qos
+
 
         return cluster_ops.create_cluster(
             blk_size, page_size_in_blocks,
             CLI_PASS, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit,
             ifname, log_del_interval, metrics_retention_period, contact_point, grafana_endpoint,
-            distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity, qpair_count)
+            distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity,
+            qpair_count, max_queue_size, inflight_io_threshold, enable_qos)
+
 
     def query_yes_no(self, question, default="yes"):
         """Ask a yes/no question via raw_input() and return their answer.

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/cluster_ops.py

@@ -103,7 +103,8 @@ def _add_graylog_input(cluster_ip, password):
 def create_cluster(blk_size, page_size_in_blocks, cli_pass,
                    cap_warn, cap_crit, prov_cap_warn, prov_cap_crit, ifname, log_del_interval, metrics_retention_period,
                    contact_point, grafana_endpoint, distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type,
-                   enable_node_affinity, qpair_count):
+                   enable_node_affinity, qpair_count, max_queue_size, inflight_io_threshold, enable_qos):
+
     logger.info("Installing dependencies...")
     ret = scripts.install_deps()
     logger.info("Installing dependencies > Done")
@@ -172,6 +173,10 @@ def create_cluster(blk_size, page_size_in_blocks, cli_pass,
     c.enable_node_affinity = enable_node_affinity
     c.qpair_count = qpair_count or 256
 
+    c.max_queue_size = max_queue_size
+    c.inflight_io_threshold = inflight_io_threshold
+    c.enable_qos = enable_qos
+
     alerts_template_folder = os.path.join(TOP_DIR, "simplyblock_core/scripts/alerting/")
     alert_resources_file = "alert_resources.yaml"
 
@@ -289,7 +294,8 @@ def deploy_spdk(node_docker, spdk_cpu_mask, spdk_mem):
 
 
 def add_cluster(blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit,
-                distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity, qpair_count):
+                distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity, qpair_count,
+                enable_qos):
     db_controller = DBController()
     clusters = db_controller.get_clusters()
     if not clusters:
@@ -322,6 +328,7 @@ def add_cluster(blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn
     cluster.ha_type = ha_type
     cluster.enable_node_affinity = enable_node_affinity
     cluster.qpair_count = qpair_count or 256
+    cluster.enable_qos = enable_qos
     if cap_warn and cap_warn > 0:
         cluster.cap_warn = cap_warn
     if cap_crit and cap_crit > 0:

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/constants.py

@@ -52,11 +52,14 @@ GRAYLOG_CHECK_INTERVAL_SEC = 60
 
 FDB_CHECK_INTERVAL_SEC = 60
 
+
+
 SIMPLY_BLOCK_DOCKER_IMAGE = "simplyblock/simplyblock:main"
 SIMPLY_BLOCK_CLI_NAME = "sbcli-dev"
 TASK_EXEC_INTERVAL_SEC = 30
 TASK_EXEC_RETRY_COUNT = 8
 
+
 SIMPLY_BLOCK_SPDK_ULTRA_IMAGE = "simplyblock/spdk:main-latest"
 
 GELF_PORT = 12202

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/controllers/device_controller.py

@@ -380,6 +380,11 @@ def device_remove(device_id, force=True):
         logger.error(f"Failed to remove bdev: {device.alceml_bdev}")
         if not force:
             return False
+    ret = rpc_client.qos_vbdev_delete(device.qos_bdev)
+    if not ret:
+        logger.error(f"Failed to remove bdev: {device.qos_bdev}")
+        if not force:
+            return False
     if snode.enable_test_device:
         ret = rpc_client.bdev_passtest_delete(device.testing_bdev)
         if not ret:

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/controllers/health_controller.py

@@ -6,7 +6,7 @@ import docker
 
 from simplyblock_core import utils, distr_controller
 from simplyblock_core.kv_store import DBController
-from simplyblock_core.models.nvme_device import NVMeDevice
+from simplyblock_core.models.nvme_device import NVMeDevice, JMDevice
 from simplyblock_core.models.storage_node import StorageNode
 from simplyblock_core.rpc_client import RPCClient
 from simplyblock_core.snode_client import SNodeClient
@@ -444,6 +444,9 @@ def check_jm_device(device_id):
         logger.info(f"Skipping ,device status is {jm_device.status}")
         return True
 
+    if snode.primary_ip != snode.mgmt_ip and jm_device.status == JMDevice.STATUS_UNAVAILABLE:
+        return True
+
     passed = True
     try:
         rpc_client = RPCClient(

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/controllers/lvol_controller.py

@@ -277,7 +277,7 @@ def validate_aes_xts_keys(key1: str, key2: str) -> Tuple[bool, str]:
 
 def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp, use_crypto,
                 distr_vuid, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes,
-                with_snapshot=False, max_size=0, crypto_key1=None, crypto_key2=None):
+                with_snapshot=False, max_size=0, crypto_key1=None, crypto_key2=None, lvol_priority_class=0):
 
     logger.info(f"Adding LVol: {name}")
     host_node = None
@@ -400,6 +400,7 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
     lvol.npcs = cl.distr_npcs
     lvol.distr_bs = cl.distr_bs
     lvol.distr_chunk_bs = cl.distr_chunk_bs
+    lvol.lvol_priority_class = lvol_priority_class
     #lvol.distr_page_size = (distr_npcs+distr_npcs)*cl.page_size_in_blocks
 
 
@@ -456,8 +457,8 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
     #         }
     #     })
     # else:
-    lvol.bdev_stack.extend(
-        [
+    #lvol.bdev_stack.extend(
+    #    [
             #{
             #    "type": "bdev_distr",
             #    "name": lvol.base_bdev,
@@ -483,17 +484,22 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
             #        "num_md_pages_per_cluster_ratio": 1,
             #    }
             #},
-            {
-                "type": "bdev_lvol",
-                "name": lvol.lvol_bdev,
-                "params": {
-                    "name": lvol.lvol_bdev,
-                    "size_in_mib": int(lvol.size/(1000*1000)),
-                    "lvs_name": lvol.lvs_name
-                }
-            }
-        ]
-    )
+
+    #    ]
+    #)
+    lvol_dict = {
+        "type": "bdev_lvol",
+        "name": lvol.lvol_bdev,
+        "params": {
+            "name": lvol.lvol_bdev,
+            "size_in_mib": int(lvol.size / (1000 * 1000)),
+            "lvs_name": lvol.lvs_name
+        }
+    }
+
+    if lvol.lvol_priority_class:
+        lvol_dict["lvol_priority_class"] = lvol.lvol_priority_class
+    lvol.bdev_stack = [lvol_dict]
 
     if use_crypto:
         if crypto_key1 == None or crypto_key2 == None:
@@ -970,7 +976,7 @@ def list_lvols(is_json, cluster_id, pool_id_or_name, all=False):
             "Size": utils.humanbytes(lvol.size),
             "Hostname": lvol.hostname,
             "HA": lvol.ha_type,
-            "VUID": lvol.vuid,
+            "Priority": lvol.lvol_priority_class,
             "Mod": f"{lvol.ndcs}x{lvol.npcs}",
             "Status": lvol.status,
             "IO Err": lvol.io_error,

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/controllers/tasks_controller.py

@@ -235,3 +235,11 @@ def get_new_device_mig_task_for_device(cluster_id):
                 return task.uuid
     return False
 
+
+def get_failed_device_mig_task(cluster_id, device_id):
+    tasks = db_controller.get_job_tasks(cluster_id)
+    for task in tasks:
+        if task.function_name == JobSchedule.FN_FAILED_DEV_MIG and task.device_id == device_id:
+            if task.status != JobSchedule.STATUS_DONE and task.canceled is False:
+                return task.uuid
+    return False

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/models/cluster.py

@@ -57,6 +57,9 @@ class Cluster(BaseModel):
         "updated_at": {"type": str, "default": ""},
         "grafana_endpoint": {"type": str, "default": ""},
         "enable_node_affinity": {"type": bool, 'default': False},
+        "max_queue_size": {"type": int, "default": 128},
+        "inflight_io_threshold": {"type": int, "default": 4},
+        "enable_qos": {"type": bool, 'default': False}
     }
 
     def __init__(self, data=None):

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/models/lvol_model.py

@@ -70,6 +70,7 @@ class LVol(BaseModel):
         "io_error": {"type": bool, 'default': False},
 
         "deletion_status": {"type": str, 'default': ""},
+        "lvol_priority_class": {"type": int, 'default': 0},
 
     }
 

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/models/nvme_device.py

@@ -52,7 +52,8 @@ class NVMeDevice(BaseModel):
         "cluster_device_order": {"type": int, 'default': 0},
         "health_check": {"type": bool, "default": True},
         "cluster_id": {"type": str, 'default': ""},
-
+        "qos_name": {"type": str, 'default': ""},
+        "alceml_name": {"type": str, 'default': ""},
         "bdev_stack": {"type": List, 'default': []},
 
         "io_error": {"type": bool, 'default': False},
@@ -106,6 +107,7 @@ class JMDevice(BaseModel):
         "raid_bdev": {"type": str, 'default': ""},
         "nvme_bdev": {"type": str, 'default': ""},
         "alceml_bdev": {"type": str, 'default': ""},
+        "alceml_name": {"type": str, 'default': ""},
         "testing_bdev": {"type": str, 'default': ""},
         "jm_bdev": {"type": str, 'default': ""},
         "device_data_dict": {"type": dict, 'default': {}},

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/rpc_client.py

@@ -1,4 +1,3 @@
-
 import json
 
 import requests
@@ -265,7 +264,7 @@ class RPCClient:
         }
         return self._request("bdev_lvol_create_lvstore", params)
 
-    def create_lvol(self, name, size_in_mib, lvs_name):
+    def create_lvol(self, name, size_in_mib, lvs_name, lvol_priority_class=0):
         params = {
             "lvol_name": name,
             "size_in_mib": size_in_mib,
@@ -273,6 +272,8 @@ class RPCClient:
             "thin_provision": True,
             "clear_method": "unmap",
         }
+        if lvol_priority_class:
+            params["lvol_priority_class"] = lvol_priority_class
         return self._request("bdev_lvol_create", params)
 
     def delete_lvol(self, name):
@@ -360,6 +361,22 @@ class RPCClient:
         params = {"name": name}
         return self._request2("ultra21_bdev_pass_delete", params)
 
+    def qos_vbdev_create(self, qos_bdev, base_bdev_name, base_nvme_hw_name, max_queue_size,
+                         inflight_io_threshold):
+        params = {
+            "base_bdev_name": base_bdev_name,
+            "name": qos_bdev,
+            "base_nvme_hw_name": base_nvme_hw_name,
+            "max_queue_size": max_queue_size,
+            "inflight_io_threshold": inflight_io_threshold
+        }
+
+        return self._request("qos_vbdev_create", params)
+
+    def qos_vbdev_delete(self, name):
+        params = {"name": name}
+        return self._request2("qos_vbdev_delete", params)
+
     def bdev_alceml_create(self, alceml_name, nvme_name, uuid, pba_init_mode=3,
                            alceml_cpu_mask="", alceml_worker_cpu_mask=""):
         params = {
@@ -381,7 +398,7 @@ class RPCClient:
         if alceml_cpu_mask:
             params["bdb_lcpu_mask"] = int(alceml_cpu_mask, 16)
         if alceml_worker_cpu_mask:
-            params["bdb_lcpu_mask_alt_workers"] = int(alceml_worker_cpu_mask,16)
+            params["bdb_lcpu_mask_alt_workers"] = int(alceml_worker_cpu_mask, 16)
         return self._request("bdev_alceml_create", params)
 
     def bdev_distrib_create(self, name, vuid, ndcs, npcs, num_blocks, block_size, jm_names,
@@ -734,7 +751,6 @@ class RPCClient:
         }
         return self._request("nbd_stop_disk", params)
 
-
     def bdev_jm_unmap_vuid(self, name, vuid):
         params = {"name": name, "vuid": vuid}
         return self._request("bdev_jm_unmap_vuid", params)

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/services/capacity_and_stats_collector.py

@@ -182,7 +182,7 @@ while True:
                 if device.status not in [NVMeDevice.STATUS_ONLINE, NVMeDevice.STATUS_READONLY]:
                     logger.info(f"Device is skipped: {device.get_id()} status: {device.status}")
                     continue
-                capacity_dict = rpc_client.alceml_get_capacity(device.alceml_bdev)
+                capacity_dict = rpc_client.alceml_get_capacity(device.alceml_name)
                 stats_dict = rpc_client.get_device_stats(device.nvme_bdev)
                 record = add_device_stats(cl, device, capacity_dict, stats_dict)
                 if record:

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_core/storage_node_ops.py

@@ -254,6 +254,18 @@ def _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart):
     else:
         raid_bdev = jm_nvme_bdevs[0]
 
+
+    # Add qos bdev device
+    #db_controller = DBController()
+    #cluster = db_controller.get_cluster_by_id(snode.cluster_id)
+    #max_queue_size = 0
+    #inflight_io_threshold = cluster.inflight_io_threshold
+    #ret = rpc_client.qos_vbdev_create(qos_bdev, raid_bdev, raid_bdev, max_queue_size, inflight_io_threshold)
+    #if not ret:
+    #    logger.error(f"Failed to create qos bdev: {qos_bdev}")
+    #    return False
+
+
     alceml_name = f"alceml_jm_{snode.get_id()}"
 
     nvme_bdev = raid_bdev
@@ -336,9 +348,9 @@ def _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart):
         'jm_nvme_bdev_list': jm_nvme_bdevs,
         'raid_bdev': raid_bdev,
         'alceml_bdev': alceml_name,
+        'alceml_name': alceml_name,
         'testing_bdev': test_name,
         'jm_bdev': jm_bdev,
-
         'pt_bdev': pt_name,
         'nvmf_nqn': subsystem_nqn,
         'nvmf_ip': IP,
@@ -347,6 +359,18 @@ 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):
+
+    # Add qos bdev device
+    #db_controller = DBController()
+    #cluster = db_controller.get_cluster_by_id(snode.cluster_id)
+    #max_queue_size = 0
+    #inflight_io_threshold = cluster.inflight_io_threshold
+    #qos_bdev = f"{nvme.nvme_bdev}_qos"
+    #ret = rpc_client.qos_vbdev_create(qos_bdev, nvme.nvme_bdev, nvme.nvme_bdev, max_queue_size, inflight_io_threshold)
+    #if not ret:
+    #    logger.error(f"Failed to create qos bdev: {qos_bdev}")
+    #    return False
+
     alceml_id = nvme.get_id()
     alceml_name = device_controller.get_alceml_name(alceml_id)
     logger.info(f"adding {alceml_name}")
@@ -427,12 +451,12 @@ def _create_jm_stack_on_device(rpc_client, nvme, snode, after_restart):
         'size': nvme.size,
         'status': JMDevice.STATUS_ONLINE,
         'alceml_bdev': alceml_name,
+        'alceml_name': alceml_name,
         'nvme_bdev': nvme.nvme_bdev,
         "serial_number": nvme.serial_number,
         "device_data_dict": nvme.to_dict(),
         'jm_bdev': jm_bdev,
         'testing_bdev': test_name,
-
         'pt_bdev': pt_name,
         'nvmf_nqn': subsystem_nqn,
         'nvmf_ip': IP,
@@ -467,15 +491,28 @@ def _create_storage_device_stack(rpc_client, nvme, snode, after_restart):
         snode.alceml_worker_cpu_index = (snode.alceml_worker_cpu_index + 1) % len(snode.alceml_worker_cpu_cores)
 
     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)
-
+                                        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: {alceml_name}")
         return False
+    alceml_bdev = alceml_name
+    db_controller = DBController()
+    cluster = db_controller.get_cluster_by_id(snode.cluster_id)
+    qos_bdev = ""
+    # Add qos bdev device
+    if cluster.enable_qos:
+        max_queue_size = cluster.max_queue_size
+        inflight_io_threshold = cluster.inflight_io_threshold
+        qos_bdev = f"{alceml_name}_qos"
+        ret = rpc_client.qos_vbdev_create(qos_bdev, alceml_name, nvme.nvme_controller, max_queue_size, inflight_io_threshold)
+        if not ret:
+            logger.error(f"Failed to create qos bdev: {qos_bdev}")
+            return False
+        alceml_bdev = qos_bdev
 
     # add pass through
     pt_name = f"{alceml_name}_PT"
-    ret = rpc_client.bdev_PT_NoExcl_create(pt_name, alceml_name)
+    ret = rpc_client.bdev_PT_NoExcl_create(pt_name, alceml_bdev)
     if not ret:
         logger.error(f"Failed to create pt noexcl bdev: {pt_name}")
         return False
@@ -507,8 +544,10 @@ def _create_storage_device_stack(rpc_client, nvme, snode, after_restart):
         return False
     if snode.enable_test_device:
         nvme.testing_bdev = test_name
-    nvme.alceml_bdev = alceml_name
+    nvme.alceml_bdev = alceml_bdev
     nvme.pt_bdev = pt_name
+    nvme.qos_bdev = qos_bdev
+    nvme.alceml_name = alceml_name
     nvme.nvmf_nqn = subsystem_nqn
     nvme.nvmf_ip = IP
     nvme.nvmf_port = 4420
@@ -713,9 +752,19 @@ def _prepare_cluster_devices_on_restart(snode):
                 logger.error(f"Failed to create passtest bdev {jm_device.testing_bdev}")
                 return False
             nvme_bdev = jm_device.testing_bdev
+
+
+        # Add qos bdev device
+        #cluster = db_controller.get_cluster_by_id(snode.cluster_id)
+        #max_queue_size = 0
+        #inflight_io_threshold = cluster.inflight_io_threshold
+        #ret = rpc_client.qos_vbdev_create(jm_device.qos_bdev, jm_device.nvme_bdev, jm_device.nvme_bdev, max_queue_size, inflight_io_threshold)
+        #if not ret:
+        #    logger.error(f"Failed to create qos bdev: {jm_device.qos_bdev}")
+        #    return False
+
         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)

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_web/blueprints/web_api_cluster.py

@@ -47,8 +47,12 @@ def add_cluster():
     enable_node_affinity = cl_data.get('enable_node_affinity', False)
     qpair_count = cl_data.get('qpair_count', 256)
 
+    max_queue_size = cl_data.get('max_queue_size', 128)
+    inflight_io_threshold = cl_data.get('inflight_io_threshold', 4)
+
     ret = cluster_ops.add_cluster(blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit,
-                                  distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity, qpair_count)
+                                  distr_ndcs, distr_npcs, distr_bs, distr_chunk_bs, ha_type, enable_node_affinity,
+                                  qpair_count, max_queue_size, inflight_io_threshold)
 
     return utils.get_response(ret)
 

{sbcli_dev-5.1.3 → sbcli_dev-5.1.5}/simplyblock_web/blueprints/web_api_lvol.py

@@ -139,6 +139,7 @@ def add_lvol():
     crypto_key1 = utils.get_value_or_default(cl_data, "crypto_key1", None)
     crypto_key2 = utils.get_value_or_default(cl_data, "crypto_key2", None)
     host_id = utils.get_value_or_default(cl_data, "host_id", None)
+    lvol_priority_class = utils.get_value_or_default(cl_data, "lvol_priority_class", 0)
 
     ret, error = lvol_controller.add_lvol_ha(
         name=name,
@@ -159,7 +160,8 @@ def add_lvol():
         crypto_key2=crypto_key2,
 
         use_comp=False,
-        distr_vuid=0
+        distr_vuid=0,
+        lvol_priority_class=lvol_priority_class
     )
 
     return utils.get_response(ret, error, http_code=400)