sbcli-dev 3.8.84__zip → 3.8.86__zip

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/PKG-INFO

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

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/env_var

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

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_cli/cli.py

@@ -238,6 +238,13 @@ class CLIWrapper:
         sub_command.add_argument("jm_device_id", help='JM device ID')
         sub_command.add_argument("--force", help='Force device remove', required=False, action='store_true')
 
+        sub_command = self.add_sub_command(subparser, 'send-cluster-map', 'send cluster map')
+        sub_command.add_argument("id", help='id')
+
+        sub_command = self.add_sub_command(subparser, 'get-cluster-map', 'get cluster map')
+        sub_command.add_argument("id", help='id')
+
+        # check lvol
         #
         # ----------------- cluster -----------------
         #
@@ -502,13 +509,6 @@ class CLIWrapper:
         sub_command.add_argument("--history", help='(XXdYYh), list history records (one for every 15 minutes) '
                                                    'for XX days and YY hours (up to 10 days in total).')
 
-        sub_command = self.add_sub_command(subparser, 'send-cluster-map', 'send cluster map')
-        sub_command.add_argument("id", help='LVol id')
-
-        sub_command = self.add_sub_command(subparser, 'get-cluster-map', 'get cluster map')
-        sub_command.add_argument("id", help='LVol id')
-
-        # check lvol
         sub_command = self.add_sub_command(subparser, "check", 'Health check LVol')
         sub_command.add_argument("id", help='UUID of LVol')
 
@@ -893,6 +893,12 @@ class CLIWrapper:
             elif sub_command == "restart-jm-device":
                 ret = device_controller.restart_jm_device(args.jm_device_id, args.force)
 
+            elif sub_command == "send-cluster-map":
+                id = args.id
+                ret = storage_ops.send_cluster_map(id)
+            elif sub_command == "get-cluster-map":
+                id = args.id
+                ret = storage_ops.get_cluster_map(id)
             else:
                 self.parser.print_help()
 
@@ -1045,12 +1051,6 @@ class CLIWrapper:
                 id = args.id
                 history = args.history
                 ret = lvol_controller.get_capacity(id, history)
-            elif sub_command == "send-cluster-map":
-                id = args.id
-                ret = lvol_controller.send_cluster_map(id)
-            elif sub_command == "get-cluster-map":
-                id = args.id
-                ret = lvol_controller.get_cluster_map(id)
             elif sub_command == "check":
                 id = args.id
                 ret = health_controller.check_lvol(id)

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_core/controllers/lvol_controller.py

@@ -1191,42 +1191,6 @@ def get_io_stats(lvol_uuid, history, records_count=20, parse_sizes=True):
     return out
 
 
-def send_cluster_map(lvol_id):
-    lvol = db_controller.get_lvol_by_id(lvol_id)
-    if not lvol:
-        logger.error(f"LVol not found: {lvol_id}")
-        return False
-
-    snode = db_controller.get_storage_node_by_id(lvol.node_id)
-    logger.info("Sending cluster map")
-    return distr_controller.send_cluster_map_to_node(snode)
-
-
-def get_cluster_map(lvol_id):
-    lvol = db_controller.get_lvol_by_id(lvol_id)
-    if not lvol:
-        logger.error(f"LVol not found: {lvol_id}")
-        return False
-
-    snode = db_controller.get_storage_node_by_id(lvol.node_id)
-    rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
-    distribs_list = []
-    for bdev in snode.lvstore_stack:
-        type = bdev['type']
-        if type == "bdev_raid":
-            distribs_list = bdev["distribs_list"]
-            if not distribs_list:
-                logger.error(f"Failed to get LVol cluster map: {lvol_id}")
-    ret = rpc_client.distr_get_cluster_map(distribs_list[0])
-    if not ret:
-        logger.error(f"Failed to get LVol cluster map: {lvol_id}")
-        return False
-    logger.debug(ret)
-    print("*"*100)
-    results, is_passed = distr_controller.parse_distr_cluster_map(ret)
-    return utils.print_table(results)
-
-
 def migrate(lvol_id, node_id):
 
     lvol = db_controller.get_lvol_by_id(lvol_id)

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_core/models/storage_node.py

@@ -91,6 +91,8 @@ class StorageNode(BaseModel):
         "alceml_cpu_index": {"type": int, "default": 0},
         "alceml_worker_cpu_index": {"type": int, "default": 0},
         "distrib_cpu_index": {"type": int, "default": 0},
+        "jc_singleton_mask": {"type": int, "default": 0},
+
 
         "distrib_cpu_mask": {"type": str, "default": ""},
 

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_core/rpc_client.py

@@ -728,6 +728,11 @@ class RPCClient:
         params = {"poll_groups_mask": poll_groups_mask}
         return self._request("nvmf_set_config", params)
 
+    def jc_set_hint_lcpu_mask(self, jc_singleton_mask):
+        params = {"hint_lcpu_mask": int(jc_singleton_mask, 16)}
+        return self._request("jc_set_hint_lcpu_mask", params)
+
+
     def thread_get_stats(self):
         return self._request("thread_get_stats")
 

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_core/storage_node_ops.py

@@ -15,7 +15,7 @@ import docker
 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
+    device_controller, tasks_controller, health_controller
 from simplyblock_core.kv_store import DBController, KVStore
 from simplyblock_core import shell_utils
 from simplyblock_core.models.iface import IFace
@@ -578,10 +578,13 @@ def _prepare_cluster_devices_partitions(snode, devices):
             if not new_device:
                 logger.error("failed to create dev stack")
                 return False
-            new_device.cluster_device_order = dev_order
-            dev_order += 1
+            if nvme.status == NVMeDevice.STATUS_NEW:
+                new_device.status = NVMeDevice.STATUS_NEW
+            else:
+                new_device.cluster_device_order = dev_order
+                dev_order += 1
+                device_events.device_create(new_device)
             new_devices.append(new_device)
-            device_events.device_create(new_device)
 
     snode.nvme_devices = new_devices
 
@@ -877,6 +880,7 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     alceml_worker_cpu_index = 0
     distrib_cpu_index = 0
 
+
     poller_cpu_cores = []
 
     if not spdk_cpu_mask:
@@ -890,11 +894,13 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
         print(f"ERROR: The provided cpu mask {spdk_cpu_mask} has values greater than 63, which is not allowed")
         return False
     if len(spdk_cores) >= 4:
-        app_thread_core, jm_cpu_core, poller_cpu_cores, alceml_cpu_cores, alceml_worker_cpu_cores, distrib_cpu_cores = utils.calculate_core_allocation(
+        app_thread_core, jm_cpu_core, poller_cpu_cores, alceml_cpu_cores, alceml_worker_cpu_cores, distrib_cpu_cores, jc_singleton_core = utils.calculate_core_allocation(
             spdk_cores)
 
         pollers_mask = utils.generate_mask(poller_cpu_cores)
         app_thread_mask = utils.generate_mask(app_thread_core)
+        if jc_singleton_core:
+            jc_singleton_mask = utils.decimal_to_hex_power_of_2(jc_singleton_core[0])
         #spdk_cpu_mask = utils.generate_mask(spdk_cores)
         jm_cpu_mask = utils.generate_mask(jm_cpu_core)
         #distrib_cpu_mask = utils.generate_mask(distrib_cpu_cores)
@@ -1057,6 +1063,7 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     snode.alceml_cpu_cores = alceml_cpu_cores
     snode.alceml_worker_cpu_cores = alceml_worker_cpu_cores
     snode.distrib_cpu_cores = distrib_cpu_cores
+    snode.jc_singleton_mask = jc_singleton_mask or 0
 
     snode.poller_cpu_cores = poller_cpu_cores or []
 
@@ -1127,6 +1134,13 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
         logger.error("Failed to set nvme options")
         return False
 
+    # 7- set jc singleton mask
+    if snode.jc_singleton_mask:
+        ret = rpc_client.jc_set_hint_lcpu_mask(snode.jc_singleton_mask)
+        if not ret:
+            logger.error("Failed to set jc singleton mask")
+            return False
+
     # get new node info after starting spdk
     node_info, _ = snode_api.info()
 
@@ -1258,7 +1272,7 @@ def delete_storage_node(node_id):
 
     for lvol in db_controller.get_lvols(snode.cluster_id):
         logger.info(f"Sending cluster map to LVol: {lvol.get_id()}")
-        lvol_controller.send_cluster_map(lvol.get_id())
+        send_cluster_map(lvol.get_id())
 
     storage_events.snode_delete(snode)
     logger.info("done")
@@ -1313,13 +1327,9 @@ def remove_storage_node(node_id, force_remove=False, force_migrate=False):
         for dev in snode.nvme_devices:
             if dev.status == NVMeDevice.STATUS_JM:
                 continue
-            if dev.status == 'online':
+            if dev.status == NVMeDevice.STATUS_ONLINE:
                 distr_controller.disconnect_device(dev)
-            old_status = dev.status
-            dev.status = NVMeDevice.STATUS_FAILED
-            distr_controller.send_dev_status_event(dev, NVMeDevice.STATUS_FAILED)
-            device_events.device_status_change(dev, NVMeDevice.STATUS_FAILED, old_status)
-            tasks_controller.add_device_failed_mig_task(dev.get_id())
+            device_controller.device_set_failed(dev.get_id())
 
     logger.info("Removing storage node")
 
@@ -1332,24 +1342,20 @@ def remove_storage_node(node_id, force_remove=False, force_migrate=False):
         pass
 
     try:
-        snode_api = SNodeClient(snode.api_endpoint, timeout=20)
-        snode_api.spdk_process_kill()
-        snode_api.leave_swarm()
-        pci_address = []
-        for dev in snode.nvme_devices:
-            if dev.pcie_address not in pci_address:
-                ret = snode_api.delete_dev_gpt_partitions(dev.pcie_address)
-                logger.debug(ret)
-                pci_address.append(dev.pcie_address)
+        if health_controller._check_node_api(snode.mgmt_ip):
+            snode_api = SNodeClient(snode.api_endpoint, timeout=20)
+            snode_api.spdk_process_kill()
+            snode_api.leave_swarm()
+            pci_address = []
+            for dev in snode.nvme_devices:
+                if dev.pcie_address not in pci_address:
+                    ret = snode_api.delete_dev_gpt_partitions(dev.pcie_address)
+                    logger.debug(ret)
+                    pci_address.append(dev.pcie_address)
     except Exception as e:
         logger.exception(e)
 
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_REMOVED
-    snode.write_to_db(db_controller.kv_store)
-    logger.info("Sending node event update")
-    distr_controller.send_node_status_event(snode, snode.status)
-    storage_events.snode_status_change(snode, StorageNode.STATUS_REMOVED, old_status)
+    set_node_status(node_id, StorageNode.STATUS_REMOVED)
     logger.info("done")
 
 
@@ -1411,15 +1417,9 @@ def restart_storage_node(
             snode.data_nics = data_nics
 
     logger.info("Setting node state to restarting")
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_RESTARTING
-    snode.write_to_db(kv_store)
-    logger.info("Sending node event update")
-    distr_controller.send_node_status_event(snode, snode.status)
-    storage_events.snode_status_change(snode, snode.status, old_status)
+    set_node_status(node_id, StorageNode.STATUS_RESTARTING)
 
     logger.info(f"Restarting Storage node: {snode.mgmt_ip}")
-
     snode_api = SNodeClient(snode.api_endpoint, timeout=5*60, retry=3)
     node_info, _ = snode_api.info()
     logger.debug(f"Node info: {node_info}")
@@ -1577,6 +1577,13 @@ def restart_storage_node(
         logger.error("Failed to set nvme options")
         return False
 
+    # 7- set jc singleton mask
+    if snode.jc_singleton_mask:
+        ret = rpc_client.jc_set_hint_lcpu_mask(snode.jc_singleton_mask)
+        if not ret:
+            logger.error("Failed to set jc singleton mask")
+            return False
+
     node_info, _ = snode_api.info()
     nvme_devs = addNvmeDevices(snode, node_info['spdk_pcie_list'])
     if not nvme_devs:
@@ -1647,11 +1654,7 @@ def restart_storage_node(
         snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
 
     logger.info("Setting node status to Online")
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_ONLINE
-    snode.write_to_db(kv_store)
-    storage_events.snode_status_change(snode, snode.status, old_status)
-
+    set_node_status(node_id, StorageNode.STATUS_ONLINE)
 
     # make other nodes connect to the new devices
     logger.info("Make other nodes connect to the node devices")
@@ -1847,52 +1850,37 @@ def shutdown_storage_node(node_id, force=False):
             return False
 
     logger.info("Shutting down node")
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_IN_SHUTDOWN
-    snode.write_to_db(db_controller.kv_store)
-    storage_events.snode_status_change(snode, snode.status, old_status)
+    set_node_status(node_id, StorageNode.STATUS_IN_SHUTDOWN)
 
-    rpc_client = RPCClient(
-        snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password, timeout=10, retry=1)
+    if health_controller._check_node_rpc(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password):
+
+        rpc_client = RPCClient(
+            snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password, timeout=10, retry=1)
+
+        logger.debug("Removing LVols")
+        _remove_bdev_stack(snode.lvstore_stack, rpc_client, remove_distr_only=True)
 
-    logger.debug("Removing LVols")
-    _remove_bdev_stack(snode.lvstore_stack, rpc_client, remove_distr_only=True)
-#    for lvol_id in snode.lvols:
-#        logger.debug(lvol_id)
-#        lvol = db_controller.get_lvol_by_id(lvol_id)
-#        lvol_controller._remove_bdev_stack([lvol.bdev_stack[0]], rpc_client)
-#        time.sleep(1)
+        if snode.jm_device:
+            # delete jm
+            logger.info("Removing JM")
+            rpc_client.bdev_jm_delete(snode.jm_device.jm_bdev)
 
     for dev in snode.nvme_devices:
         if dev.status in [NVMeDevice.STATUS_ONLINE, NVMeDevice.STATUS_READONLY]:
             device_controller.device_set_unavailable(dev.get_id())
-    distr_controller.send_node_status_event(snode, StorageNode.STATUS_IN_SHUTDOWN)
 
-    # shutdown node
     # make other nodes disconnect from this node
     logger.info("disconnect all other nodes connections to this node")
     for dev in snode.nvme_devices:
         distr_controller.disconnect_device(dev)
 
-    if snode.jm_device:
-        # delete jm
-        logger.info("Removing JM")
-        rpc_client.bdev_jm_delete(snode.jm_device.jm_bdev)
-
     logger.info("Stopping SPDK")
-    snode_api = SNodeClient(snode.api_endpoint)
-    results, err = snode_api.spdk_process_kill()
+    if health_controller._check_node_api(snode.mgmt_ip):
+        snode_api = SNodeClient(snode.api_endpoint)
+        results, err = snode_api.spdk_process_kill()
 
     logger.info("Setting node status to offline")
-    snode = db_controller.get_storage_node_by_id(node_id)
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_OFFLINE
-    snode.write_to_db(db_controller.kv_store)
-
-    for dev in snode.nvme_devices:
-        if dev.status in [NVMeDevice.STATUS_ONLINE, NVMeDevice.STATUS_READONLY]:
-            device_controller.device_set_unavailable(dev.get_id())
-    distr_controller.send_node_status_event(snode, StorageNode.STATUS_OFFLINE)
+    set_node_status(node_id, StorageNode.STATUS_OFFLINE)
 
     tasks = db_controller.get_job_tasks(snode.cluster_id)
     for task in tasks:
@@ -1900,8 +1888,6 @@ def shutdown_storage_node(node_id, force=False):
             task.canceled = True
             task.write_to_db(db_controller.kv_store)
 
-    # send event log
-    storage_events.snode_status_change(snode, snode.status, old_status)
     logger.info("Done")
     return True
 
@@ -1943,7 +1929,6 @@ def suspend_storage_node(node_id, force=False):
             return False
 
     logger.info("Suspending node")
-    distr_controller.send_node_status_event(snode, StorageNode.STATUS_SUSPENDED)
     for dev in snode.nvme_devices:
         if dev.status == NVMeDevice.STATUS_ONLINE:
             device_controller.device_set_unavailable(dev.get_id())
@@ -1962,12 +1947,7 @@ def suspend_storage_node(node_id, force=False):
             lvol.write_to_db(db_controller.kv_store)
 
     logger.info("Setting node status to suspended")
-    snode = db_controller.get_storage_node_by_id(node_id)
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_SUSPENDED
-    snode.write_to_db(db_controller.kv_store)
-
-    storage_events.snode_status_change(snode, snode.status, old_status)
+    set_node_status(node_id, StorageNode.STATUS_SUSPENDED)
     logger.info("Done")
     return True
 
@@ -1990,10 +1970,6 @@ def resume_storage_node(node_id):
         return False
 
     logger.info("Resuming node")
-
-    logger.info("Sending cluster event updates")
-    distr_controller.send_node_status_event(snode, StorageNode.STATUS_ONLINE)
-
     for dev in snode.nvme_devices:
         if dev.status == NVMeDevice.STATUS_UNAVAILABLE:
             device_controller.device_set_online(dev.get_id())
@@ -2012,12 +1988,7 @@ def resume_storage_node(node_id):
             lvol.write_to_db(db_controller.kv_store)
 
     logger.info("Setting node status to online")
-    snode = db_controller.get_storage_node_by_id(node_id)
-    old_status = snode.status
-    snode.status = StorageNode.STATUS_ONLINE
-    snode.write_to_db(db_controller.kv_store)
-
-    storage_events.snode_status_change(snode, snode.status, old_status)
+    set_node_status(node_id, StorageNode.STATUS_ONLINE)
     logger.info("Done")
     return True
 
@@ -2550,6 +2521,31 @@ def recreate_lvstore(snode):
     return True
 
 
+def get_next_ha_jm_names(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)
+        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)
+
+    jm_count = dict(sorted(jm_count.items(), key=lambda x: x[1]))
+
+    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")
+
+    return jm_list
+
+
 def create_lvstore(snode, ndcs, npcs, distr_bs, distr_chunk_bs, page_size_in_blocks, max_size, nodes):
     lvstore_stack = []
     distrib_list = []
@@ -2742,3 +2738,41 @@ def _remove_bdev_stack(bdev_stack, rpc_client, remove_distr_only=False):
 
         bdev['status'] = 'deleted'
         time.sleep(1)
+
+
+def send_cluster_map(node_id):
+    db_controller = DBController()
+    snode = db_controller.get_storage_node_by_id(node_id)
+    if not snode:
+        logger.error(f"snode not found: {node_id}")
+        return False
+
+    logger.info("Sending cluster map")
+    return distr_controller.send_cluster_map_to_node(snode)
+
+
+def get_cluster_map(node_id):
+    db_controller = DBController()
+    snode = db_controller.get_storage_node_by_id(node_id)
+    if not snode:
+        logger.error(f"snode not found: {node_id}")
+        return False
+
+    rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
+    distribs_list = []
+    for bdev in snode.lvstore_stack:
+        type = bdev['type']
+        if type == "bdev_raid":
+            distribs_list = bdev["distribs_list"]
+            if not distribs_list:
+                logger.error(f"Failed to get cluster map: {node_id}")
+    for distr in distribs_list:
+        ret = rpc_client.distr_get_cluster_map(distr)
+        if not ret:
+            logger.error(f"Failed to get distr cluster map: {distr}")
+            return False
+        logger.debug(ret)
+        print("*"*100)
+        results, is_passed = distr_controller.parse_distr_cluster_map(ret)
+        print(utils.print_table(results))
+    return True

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_core/utils.py

@@ -350,59 +350,67 @@ def calculate_core_allocation(cpu_cores):
     if len(cpu_cores) == 23:
         app_thread_core = [cpu_cores[pos - 1] for pos in [16]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [17, 22]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [6, 7, 8, 14, 15, 18, 19, 20, 23]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [6, 7, 8, 14, 15, 18, 19, 20]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1, 2, 3]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [13, 21]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [4, 5, 9, 10, 11, 12]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [23]]
     elif len(cpu_cores) == 21:
         app_thread_core = [cpu_cores[pos - 1] for pos in [14]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [15, 21]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [4, 5, 6, 7, 13, 16, 17, 18]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [4, 5, 6, 7, 13, 16, 17]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1, 2]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [12, 20]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 8, 9, 10, 11, 19]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [18]]
     elif len(cpu_cores) == 19:
         app_thread_core = [cpu_cores[pos - 1] for pos in [13]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [14]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [5, 6, 7, 12, 15, 16, 17]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [5, 6, 7, 12, 15, 16]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1, 2]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [11, 19]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 8, 9, 10, 18]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [17]]
     elif len(cpu_cores) == 17:
         app_thread_core = [cpu_cores[pos - 1] for pos in [12]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [13]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [4, 5, 6, 11, 14, 15]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [4, 5, 6, 11, 14]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1, 2]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [10]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 7, 8, 9, 16, 17]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [15]]
     elif len(cpu_cores) == 15:
         app_thread_core = [cpu_cores[pos - 1] for pos in [11]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [12]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [5, 6, 10, 13, 14]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [5, 6, 10, 13]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1, 2]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [9]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 7, 8, 15]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [14]]
     elif len(cpu_cores) == 13:
         app_thread_core = [cpu_cores[pos - 1] for pos in [9]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [10]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 5, 11, 12]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 5, 11]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [8]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [2, 6, 7, 13]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [12]]
     elif len(cpu_cores) == 11:
         app_thread_core = [cpu_cores[pos - 1] for pos in [8]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [9]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 10, 11]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 10]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [7]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [2, 5, 6]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [11]]
     elif len(cpu_cores) == 9:
         app_thread_core = [cpu_cores[pos - 1] for pos in [7]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [8]]
-        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4, 9]]
+        poller_cpu_cores = [cpu_cores[pos - 1] for pos in [3, 4]]
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [4, 9]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [2, 5, 6]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [7]]
     elif len(cpu_cores) == 7:
         app_thread_core = [cpu_cores[pos - 1] for pos in [6]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [7]]
@@ -410,6 +418,7 @@ def calculate_core_allocation(cpu_cores):
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [1]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [2, 4]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [6]]
     elif len(cpu_cores) == 5:
         app_thread_core = [cpu_cores[pos - 1] for pos in [5]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [4]]
@@ -417,6 +426,7 @@ def calculate_core_allocation(cpu_cores):
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [1]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [2, 3]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [5]]
     elif len(cpu_cores) == 4:
         app_thread_core = [cpu_cores[pos - 1] for pos in [4]]
         jm_cpu_core = [cpu_cores[pos - 1] for pos in [4]]
@@ -424,10 +434,11 @@ def calculate_core_allocation(cpu_cores):
         alceml_cpu_cores = [cpu_cores[pos - 1] for pos in [1]]
         alceml_cpu_worker_cores = [cpu_cores[pos - 1] for pos in [1]]
         distrib_cpu_cores = [cpu_cores[pos - 1] for pos in [2, 3]]
+        jc_singleton_core = [cpu_cores[pos - 1] for pos in [4]]
     else:
-        app_thread_core = jm_cpu_core = poller_cpu_cores = alceml_cpu_cores = alceml_cpu_worker_cores = distrib_cpu_cores = []
+        app_thread_core = jm_cpu_core = poller_cpu_cores = alceml_cpu_cores = alceml_cpu_worker_cores = distrib_cpu_cores = jc_singleton_core = []
 
-    return app_thread_core, jm_cpu_core, poller_cpu_cores, alceml_cpu_cores, alceml_cpu_worker_cores, distrib_cpu_cores
+    return app_thread_core, jm_cpu_core, poller_cpu_cores, alceml_cpu_cores, alceml_cpu_worker_cores, distrib_cpu_cores, jc_singleton_core
 
 
 def generate_mask(cores):

{sbcli_dev-3.8.84 → sbcli_dev-3.8.86}/simplyblock_web/templates/storage_deploy_spdk.yaml.j2

@@ -89,10 +89,10 @@ spec:
           mountPath: /script
         resources:
           limits:
-            hugepages-2Mi: {{ MEM_GEGA }}Gi
-            memory: 4096Mi
+            hugepages-2Mi: 20Gi
+            memory: 10Gi
           requests:
-            memory: 4096Mi
+            memory: 10Gi
 
       - name: spdk-proxy-container
         image: {{ SIMPLYBLOCK_DOCKER_IMAGE }}