sbcli-dev 19.2.3__tar.gz → 19.2.5__tar.gz

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/PKG-INFO

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

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/sbcli_dev.egg-info/SOURCES.txt

@@ -28,7 +28,6 @@ simplyblock_core/snode_client.py
 simplyblock_core/storage_node_ops.py
 simplyblock_core/utils.py
 simplyblock_core/controllers/__init__.py
-simplyblock_core/controllers/caching_node_controller.py
 simplyblock_core/controllers/cluster_events.py
 simplyblock_core/controllers/device_controller.py
 simplyblock_core/controllers/device_events.py
@@ -47,7 +46,6 @@ simplyblock_core/controllers/tasks_events.py
 simplyblock_core/controllers/tcp_ports_events.py
 simplyblock_core/models/__init__.py
 simplyblock_core/models/base_model.py
-simplyblock_core/models/caching_node.py
 simplyblock_core/models/cluster.py
 simplyblock_core/models/deployer.py
 simplyblock_core/models/events.py
@@ -95,8 +93,6 @@ simplyblock_core/scripts/helpers/deploy_cluster.sh
 simplyblock_core/scripts/helpers/destroy_cluster.sh
 simplyblock_core/scripts/helpers/nvme_disconnect_by_ip.py
 simplyblock_core/services/__init__.py
-simplyblock_core/services/cached_lvol_stat_collector.py
-simplyblock_core/services/caching_node_monitor.py
 simplyblock_core/services/cap_monitor.py
 simplyblock_core/services/capacity_and_stats_collector.py
 simplyblock_core/services/device_monitor.py
@@ -133,13 +129,10 @@ simplyblock_web/node_utils_k8s.py
 simplyblock_web/node_webapp.py
 simplyblock_web/utils.py
 simplyblock_web/blueprints/__init__.py
-simplyblock_web/blueprints/caching_node_ops.py
-simplyblock_web/blueprints/caching_node_ops_k8s.py
 simplyblock_web/blueprints/node_api_basic.py
 simplyblock_web/blueprints/snode_ops.py
 simplyblock_web/blueprints/snode_ops_k8s.py
 simplyblock_web/blueprints/swagger_ui_blueprint.py
-simplyblock_web/blueprints/web_api_caching_node.py
 simplyblock_web/blueprints/web_api_cluster.py
 simplyblock_web/blueprints/web_api_deployer.py
 simplyblock_web/blueprints/web_api_device.py
@@ -160,6 +153,7 @@ simplyblock_web/static/rpac.yaml
 simplyblock_web/static/swagger.yaml
 simplyblock_web/static/tst.py
 simplyblock_web/templates/caching_deploy_spdk.yaml.j2
+simplyblock_web/templates/storage_core_isolation.yaml.j2
 simplyblock_web/templates/storage_deploy_spdk.yaml.j2
 simplyblock_web/templates/storage_init_job.yaml.j2
 simplyblock_web/test/conftest.py

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_cli/cli.py

@@ -27,7 +27,6 @@ class CLIWrapper(CLIWrapperBase):
         self.init_control_plane()
         self.init_storage_pool()
         self.init_snapshot()
-        self.init_caching_node()
         super().__init__()
 
     def init_storage_node(self):
@@ -169,6 +168,7 @@ class CLIWrapper(CLIWrapperBase):
             argument = subcommand.add_argument('--iobuf_large_bufsize', help='bdev_set_options param', type=int, default=0, dest='large_bufsize')
         argument = subcommand.add_argument('--force', help='Force restart', dest='force', action='store_true')
         argument = subcommand.add_argument('--ssd-pcie', help='New Nvme PCIe address to add to the storage node. Can be more than one.', type=str, default='', dest='ssd_pcie', required=False, nargs='+')
+        argument = subcommand.add_argument('--force-lvol-recreate', help='Force LVol recreate on node restart even if lvol bdev was not recovered', type=bool, dest='force_lvol_recreate')
 
     def init_storage_node__shutdown(self, subparser):
         subcommand = self.add_sub_command(subparser, 'shutdown', 'Initiates a storage node shutdown')
@@ -655,8 +655,6 @@ class CLIWrapper(CLIWrapperBase):
         argument = subcommand.add_argument('--max-rw-mbytes', help='Maximum Read Write Megabytes Per Second', type=int, dest='max_rw_mbytes')
         argument = subcommand.add_argument('--max-r-mbytes', help='Maximum Read Megabytes Per Second', type=int, dest='max_r_mbytes')
         argument = subcommand.add_argument('--max-w-mbytes', help='Maximum Write Megabytes Per Second', type=int, dest='max_w_mbytes')
-        if self.developer_mode:
-            argument = subcommand.add_argument('--has-secret', help='Pool is created with a secret (all further API interactions with the pool and logical volumes in the pool require this secret)', dest='has_secret', action='store_true')
 
     def init_storage_pool__set(self, subparser):
         subcommand = self.add_sub_command(subparser, 'set', 'Sets a storage pool\'s attributes')
@@ -730,70 +728,6 @@ class CLIWrapper(CLIWrapperBase):
         argument = subcommand.add_argument('--resize', help='New logical volume size: 10M, 10G, 10(bytes). Can only increase.', type=size_type(), default='0', dest='resize')
 
 
-    def init_caching_node(self):
-        subparser = self.add_command('caching-node', 'Caching node commands', aliases=['cn',])
-        self.init_caching_node__deploy(subparser)
-        self.init_caching_node__add_node(subparser)
-        self.init_caching_node__list(subparser)
-        self.init_caching_node__list_lvols(subparser)
-        self.init_caching_node__remove(subparser)
-        self.init_caching_node__connect(subparser)
-        self.init_caching_node__disconnect(subparser)
-        self.init_caching_node__recreate(subparser)
-        self.init_caching_node__get_lvol_stats(subparser)
-
-
-    def init_caching_node__deploy(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'deploy', 'Deploys a caching node on this machine (local run)')
-        argument = subcommand.add_argument('--ifname', help='Management interface name, e.g. eth0', type=str, dest='ifname')
-
-    def init_caching_node__add_node(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'add-node', 'Adds a new caching node to the cluster')
-        subcommand.add_argument('cluster_id', help='Cluster id', type=str)
-        subcommand.add_argument('node_ip', help='Node IP address', type=str)
-        subcommand.add_argument('ifname', help='Management interface name', type=str)
-        argument = subcommand.add_argument('--vcpu-count', help='Number of vCPUs used for SPDK. Remaining CPUs will be used for Linux system, TCP/IP processing, and other workloads. The default on non-Kubernetes hosts is 80%%.', type=int, dest='vcpu_count')
-        if self.developer_mode:
-            argument = subcommand.add_argument('--cpu-mask', help='SPDK app CPU mask, default is all cores found', type=regex_type(r'^(0x|0X)?[a-fA-F0-9]+$'), dest='spdk_cpu_mask')
-        if self.developer_mode:
-            argument = subcommand.add_argument('--memory', help='SPDK huge memory allocation. By default it will acquire all available huge pages.', type=size_type(min=utils.parse_size('1G'), max=None), dest='spdk_mem')
-        if self.developer_mode:
-            argument = subcommand.add_argument('--spdk-image', help='SPDK image uri', type=str, dest='spdk_image')
-        argument = subcommand.add_argument('--namespace', help='k8s namespace to deploy on', type=str, dest='namespace')
-        argument = subcommand.add_argument('--multipathing', help='Enable multipathing for logical volume connection, default: on', type=str, default='True', dest='multipathing', choices=['on','off',])
-
-    def init_caching_node__list(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'list', 'Lists all caching nodes')
-
-    def init_caching_node__list_lvols(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'list-lvols', 'Lists all connected logical volumes')
-        subcommand.add_argument('node_id', help='Caching node id', type=str)
-
-    def init_caching_node__remove(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'remove', 'Removes a caching node from the cluster')
-        subcommand.add_argument('node_id', help='Caching node id', type=str)
-        argument = subcommand.add_argument('--force', help='Force remove', dest='force', action='store_true')
-
-    def init_caching_node__connect(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'connect', 'Connects a logical volume to the caching node')
-        subcommand.add_argument('node_id', help='Caching node id', type=str)
-        subcommand.add_argument('lvol_id', help='Logical volume id', type=str)
-
-    def init_caching_node__disconnect(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'disconnect', 'Disconnects a logical volume from the caching node')
-        subcommand.add_argument('node_id', help='Caching node id', type=str)
-        subcommand.add_argument('lvol_id', help='Logical volume id', type=str)
-
-    def init_caching_node__recreate(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'recreate', 'Recreate a caching node\'s bdevs')
-        subcommand.add_argument('node_id', help='Caching node id', type=str)
-
-    def init_caching_node__get_lvol_stats(self, subparser):
-        subcommand = self.add_sub_command(subparser, 'get-lvol-stats', 'Gets a logical volume\'s statistics')
-        subcommand.add_argument('lvol_id', help='Logical volume id', type=str)
-        argument = subcommand.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).', type=str, dest='history')
-
-
     def run(self):
         args = self.parser.parse_args()
         if args.debug:
@@ -1076,8 +1010,6 @@ class CLIWrapper(CLIWrapperBase):
             elif args.command in ['storage-pool', 'pool']:
                 sub_command = args_dict['storage-pool']
                 if sub_command in ['add']:
-                    if not self.developer_mode:
-                        args.has_secret = None
                     ret = self.storage_pool__add(sub_command, args)
                 elif sub_command in ['set']:
                     ret = self.storage_pool__set(sub_command, args)
@@ -1111,33 +1043,6 @@ class CLIWrapper(CLIWrapperBase):
                 else:
                     self.parser.print_help()
 
-            elif args.command in ['caching-node', 'cn']:
-                sub_command = args_dict['caching-node']
-                if sub_command in ['deploy']:
-                    ret = self.caching_node__deploy(sub_command, args)
-                elif sub_command in ['add-node']:
-                    if not self.developer_mode:
-                        args.spdk_cpu_mask = None
-                        args.spdk_mem = None
-                        args.spdk_image = None
-                    ret = self.caching_node__add_node(sub_command, args)
-                elif sub_command in ['list']:
-                    ret = self.caching_node__list(sub_command, args)
-                elif sub_command in ['list-lvols']:
-                    ret = self.caching_node__list_lvols(sub_command, args)
-                elif sub_command in ['remove']:
-                    ret = self.caching_node__remove(sub_command, args)
-                elif sub_command in ['connect']:
-                    ret = self.caching_node__connect(sub_command, args)
-                elif sub_command in ['disconnect']:
-                    ret = self.caching_node__disconnect(sub_command, args)
-                elif sub_command in ['recreate']:
-                    ret = self.caching_node__recreate(sub_command, args)
-                elif sub_command in ['get-lvol-stats']:
-                    ret = self.caching_node__get_lvol_stats(sub_command, args)
-                else:
-                    self.parser.print_help()
-
             else:
                 self.parser.print_help()
 

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_cli/clibase.py

@@ -13,7 +13,7 @@ from simplyblock_core import storage_node_ops as storage_ops
 from simplyblock_core import mgmt_node_ops as mgmt_ops
 from simplyblock_core.controllers import pool_controller, lvol_controller, snapshot_controller, device_controller, \
     tasks_controller
-from simplyblock_core.controllers import caching_node_controller, health_controller
+from simplyblock_core.controllers import health_controller
 from simplyblock_core.models.pool import Pool
 from simplyblock_core.models.cluster import Cluster
 
@@ -188,7 +188,7 @@ class CLIWrapperBase:
             node_id, max_lvol, max_snap, max_prov,
             spdk_image, spdk_debug,
             small_bufsize, large_bufsize, node_ip=args.node_ip, reattach_volume=reattach_volume, force=args.force,
-            new_ssd_pcie=ssd_pcie)
+            new_ssd_pcie=ssd_pcie, force_lvol_recreate=args.force_lvol_recreate)
 
     def storage_node__shutdown(self, sub_command, args):
         return storage_ops.shutdown_storage_node(args.node_id, args.force)
@@ -553,9 +553,6 @@ class CLIWrapperBase:
         return mgmt_ops.remove_mgmt_node(args.node_id)
 
     def storage_pool__add(self, sub_command, args):
-        has_secret = args.has_secret
-        if has_secret is None:
-            has_secret = False
         return pool_controller.add_pool(
             args.name,
             args.pool_max,
@@ -564,7 +561,6 @@ class CLIWrapperBase:
             args.max_rw_mbytes,
             args.max_r_mbytes,
             args.max_w_mbytes,
-            has_secret,
             args.cluster_id
         )
 
@@ -625,48 +621,6 @@ class CLIWrapperBase:
         success, details = snapshot_controller.clone(args.snapshot_id, args.lvol_name, new_size)
         return details
 
-    def caching_node__deploy(self, sub_command, args):
-        return caching_node_controller.deploy(args.ifname)
-
-    def caching_node__add_node(self, sub_command, args):
-        cluster_id = args.cluster_id
-        node_ip = args.node_ip
-        ifname = args.ifname
-        data_nics = []
-        spdk_image = args.spdk_image
-        namespace = args.namespace
-        multipathing = args.multipathing == "on"
-        spdk_cpu_mask = args.spdk_cpu_mask
-        spdk_mem = args.spdk_mem
-
-        return caching_node_controller.add_node(
-            cluster_id, node_ip, ifname, data_nics, spdk_cpu_mask, spdk_mem, spdk_image, namespace, multipathing)
-
-    def caching_node__list(self, sub_command, args):
-        return caching_node_controller.list_nodes()
-
-    def caching_node__list_lvols(self, sub_command, args):
-        return caching_node_controller.list_lvols(args.node_id)
-
-    def caching_node__remove(self, sub_command, args):
-        return caching_node_controller.remove_node(args.node_id, args.force)
-
-    def caching_node__connect(self, sub_command, args):
-        return caching_node_controller.connect(args.node_id, args.lvol_id)
-
-    def caching_node__disconnect(self, sub_command, args):
-        return caching_node_controller.disconnect(args.node_id, args.lvol_id)
-
-    def caching_node__recreate(self, sub_command, args):
-        return caching_node_controller.recreate(args.node_id)
-
-    def caching_node__get_lvol_stats(self, sub_command, args):
-        data = caching_node_controller.get_io_stats(args.lvol_id, args.history)
-        if data:
-            return utils.print_table(data)
-        else:
-            return False
-
     def storage_node_list_devices(self, args):
         node_id = args.node_id
         is_json = args.json

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/cluster_ops.py

@@ -506,7 +506,7 @@ def cluster_expand(cl_id) -> None:
             secondary_nodes = storage_node_ops.get_secondary_nodes(snode)
             if not secondary_nodes:
                 set_cluster_status(cl_id, ols_status)
-                raise ValueError("Failed to expand cluster, No enough secondary nodes")
+                raise ValueError("A minimum of 2 new nodes are required to expand cluster")
 
             snode = db_controller.get_storage_node_by_id(snode.get_id())
             snode.secondary_node_id = secondary_nodes[0]

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/controllers/lvol_controller.py

@@ -9,7 +9,7 @@ from datetime import datetime
 from typing import Tuple
 
 from simplyblock_core import utils, constants
-from simplyblock_core.controllers import snapshot_controller, pool_controller, lvol_events, caching_node_controller
+from simplyblock_core.controllers import snapshot_controller, pool_controller, lvol_events
 from simplyblock_core.db_controller import DBController
 from simplyblock_core.models.pool import Pool
 from simplyblock_core.models.lvol_model import LVol
@@ -873,13 +873,6 @@ def delete_lvol(id_or_name, force_delete=False):
         logger.info("Done")
         return True
 
-    # disconnect from caching nodes:
-    cnodes = db_controller.get_caching_nodes()
-    for cnode in cnodes:
-        for lv in cnode.lvols:
-            if lv.lvol_id == lvol.get_id():
-                caching_node_controller.disconnect(cnode.get_id(), lvol.get_id())
-
     if lvol.ha_type == 'single':
         if snode.status  != StorageNode.STATUS_ONLINE:
             logger.error(f"Node status is not online, node: {snode.get_id()}, status: {snode.status}")

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/controllers/pool_controller.py

@@ -22,7 +22,7 @@ def _generate_string(length):
         string.ascii_letters + string.digits) for _ in range(length))
 
 
-def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, has_secret, cluster_id):
+def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes, max_w_mbytes, cluster_id):
     db_controller = DBController()
     if not name:
         logger.error("Pool name is empty!")
@@ -58,8 +58,6 @@ def add_pool(name, pool_max, lvol_max, max_rw_iops, max_rw_mbytes, max_r_mbytes,
     pool.cluster_id = cluster.get_id()
     pool.numeric_id = _generate_numeric_id(pool_list)
     pool.pool_name = name
-    if has_secret:
-        pool.secret = _generate_string(20)
     pool.pool_max_size = pool_max
     pool.lvol_max_size = lvol_max
     pool.max_rw_ios_per_sec = max_rw_iops
@@ -304,36 +302,6 @@ def get_io_stats(pool_id, history, records_count=20):
     return utils.print_table(out)
 
 
-def get_secret(pool_id):
-    db_controller = DBController()
-    try:
-        pool = db_controller.get_pool_by_id(pool_id)
-    except KeyError:
-        logger.error(f"Pool not found {pool_id}")
-        return False
-
-    if pool.secret:
-        return pool.secret
-    else:
-        return "Pool has no secret"
-
-
-def set_secret(pool_id, secret):
-    db_controller = DBController()
-    try:
-        pool = db_controller.get_pool_by_id(pool_id)
-    except KeyError:
-        logger.error(f"Pool not found {pool_id}")
-        return False
-
-    secret = secret.strip()
-    if len(secret) < 20:
-        return "Secret must be at least 20 char"
-
-    pool.secret = secret
-    pool.write_to_db(db_controller.kv_store)
-
-
 def get_pool_total_capacity(pool_id):
     db_controller = DBController()
     try:

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/db_controller.py

@@ -5,7 +5,6 @@ import fdb
 from typing import List, Optional
 
 from simplyblock_core import constants
-from simplyblock_core.models.caching_node import CachingNode
 from simplyblock_core.models.cluster import Cluster
 from simplyblock_core.models.deployer import Deployer
 from simplyblock_core.models.events import EventObj
@@ -89,32 +88,6 @@ class DBController(metaclass=Singleton):
             raise KeyError(f'StorageNode {id} not found')
         return ret[0]
 
-    # todo: change this function for multi cluster
-    def get_caching_nodes(self) -> List[CachingNode]:
-        ret = CachingNode().read_from_db(self.kv_store)
-        ret = sorted(ret, key=lambda x: x.create_dt)
-        return ret
-
-    def get_caching_node_by_id(self, id)  -> Optional[CachingNode]:
-        ret = CachingNode().read_from_db(self.kv_store, id)
-        if ret:
-            return ret[0]
-        return None
-
-    def get_caching_node_by_system_id(self, system_id)  -> Optional[CachingNode]:
-        nodes = CachingNode().read_from_db(self.kv_store)
-        for node in nodes:
-            if node.system_uuid == system_id:
-                return node
-        return None
-
-    def get_caching_node_by_hostname(self, hostname)  -> Optional[CachingNode]:
-        nodes = self.get_caching_nodes()
-        for node in nodes:
-            if node.hostname == hostname:
-                return node
-        return None
-
     def get_storage_node_by_hostname(self, hostname) -> Optional[StorageNode]:
         nodes = self.get_storage_nodes()
         for node in nodes:

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=19.2.3
+SIMPLY_BLOCK_VERSION=19.2.5
 
 
 SIMPLY_BLOCK_DOCKER_IMAGE=public.ecr.aws/simply-block/simplyblock:main

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/models/pool.py

@@ -26,7 +26,7 @@ class Pool(BaseModel):
     pool_max_size: int = 0
     pool_name: str = ""
     numeric_id: int = 0
-    secret: str = ""
+    secret: str = ""  # unused
     users: List[str] = []
 
 

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/scripts/docker-compose-swarm.yml

@@ -29,7 +29,7 @@ services:
       placement:
         constraints: [ node.role == manager ]
       resources:
-        limits:
+        reservations:
           memory: 4g
 
   fdb-backup-agent:
@@ -92,20 +92,6 @@ services:
     environment:
       SIMPLYBLOCK_LOG_LEVEL: "$LOG_LEVEL"
 
-  CachingNodeMonitor:
-    <<: *service-base
-    image: $SIMPLYBLOCK_DOCKER_IMAGE
-    command: "python simplyblock_core/services/caching_node_monitor.py"
-    deploy:
-      placement:
-        constraints: [node.role == manager]
-    volumes:
-      - "/etc/foundationdb:/etc/foundationdb"
-    networks:
-      - hostnet
-    environment:
-      SIMPLYBLOCK_LOG_LEVEL: "$LOG_LEVEL"
-
   LVolStatsCollector:
     <<: *service-base
     image: $SIMPLYBLOCK_DOCKER_IMAGE

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/services/health_check_service.py

@@ -208,7 +208,7 @@ while True:
 
                 lvstore_check = True
                 snode = db.get_storage_node_by_id(snode.get_id())
-                if snode.lvstore_status == "ready":
+                if snode.status == StorageNode.STATUS_ONLINE:
 
                     lvstore_stack = snode.lvstore_stack
                     lvstore_check &= health_controller._check_node_lvstore(

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/services/tasks_runner_port_allow.py

@@ -68,7 +68,7 @@ while True:
                             logger.info(f"Check 2: ping mgmt ip {node.mgmt_ip} ... {ping_check}")
 
                         if not ping_check:
-                            msg = f"Node ping is false, retry task"
+                            msg = "Node ping is false, retry task"
                             logger.info(msg)
                             task.function_result = msg
                             task.status = JobSchedule.STATUS_SUSPENDED
@@ -105,7 +105,7 @@ while True:
                                 node.remote_devices = remote_devices
                                 node.write_to_db()
                             else:
-                                msg = f"Node unable to connect to remote devs, retry task"
+                                msg = "Node unable to connect to remote devs, retry task"
                                 logger.info(msg)
                                 task.function_result = msg
                                 task.status = JobSchedule.STATUS_SUSPENDED
@@ -114,7 +114,7 @@ while True:
 
                         except Exception as e:
                             logger.error(e)
-                            msg = f"Error when connect to remote devs, retry task"
+                            msg = "Error when connect to remote devs, retry task"
                             logger.info(msg)
                             task.function_result = msg
                             task.status = JobSchedule.STATUS_SUSPENDED

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_core/storage_node_ops.py

@@ -1361,7 +1361,7 @@ def restart_storage_node(
         node_id, max_lvol=0, max_snap=0, max_prov=0,
         spdk_image=None, set_spdk_debug=None,
         small_bufsize=0, large_bufsize=0,
-        force=False, node_ip=None, reattach_volume=False, clear_data=False, new_ssd_pcie=[]):
+        force=False, node_ip=None, reattach_volume=False, clear_data=False, new_ssd_pcie=[], force_lvol_recreate=False):
     db_controller = DBController()
     kv_store = db_controller.kv_store
 
@@ -1793,7 +1793,7 @@ def restart_storage_node(
         snode = db_controller.get_storage_node_by_id(snode.get_id())
         logger.info("Recreate lvstore")
         try:
-            ret = recreate_lvstore(snode, force=force)
+            ret = recreate_lvstore(snode, force=force_lvol_recreate)
         except Exception as e:
             logger.error(e)
             return False
@@ -3005,7 +3005,7 @@ def recreate_lvstore(snode, force=False):
             fw_api.firewall_set_port(snode.lvol_subsys_port, "tcp", "block", sec_node.rpc_port)
             tcp_ports_events.port_deny(sec_node, snode.lvol_subsys_port)
 
-            # time.sleep(0.2)
+            time.sleep(0.5)
             ### 4- set leadership to false
             sec_rpc_client.bdev_lvol_set_leader(snode.lvstore, leader=False, bs_nonleadership=True)
             sec_rpc_client.bdev_distrib_force_to_non_leader(snode.jm_vuid)
@@ -3015,7 +3015,7 @@ def recreate_lvstore(snode, force=False):
             rpc_client.jc_explicit_synchronization(snode.jm_vuid)
 
     ### 5- examine
-    time.sleep(0.2)
+    # time.sleep(0.2)
     rpc_client.bdev_distrib_force_to_non_leader(snode.jm_vuid)
     ret = rpc_client.bdev_examine(snode.raid)
     # time.sleep(1)

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_web/app.py

@@ -6,7 +6,7 @@ from flask import Flask
 
 from simplyblock_web import utils
 from simplyblock_web.blueprints import web_api_cluster, web_api_mgmt_node, web_api_device, \
-    web_api_lvol, web_api_storage_node, web_api_pool, web_api_caching_node, \
+    web_api_lvol, web_api_storage_node, web_api_pool, \
     web_api_snapshot, web_api_deployer, swagger_ui_blueprint, web_api_metrics
 from simplyblock_web.auth_middleware import token_required
 from simplyblock_core import constants, utils as core_utils
@@ -31,7 +31,6 @@ app.register_blueprint(web_api_lvol.bp)
 app.register_blueprint(web_api_snapshot.bp)
 app.register_blueprint(web_api_storage_node.bp)
 app.register_blueprint(web_api_pool.bp)
-app.register_blueprint(web_api_caching_node.bp)
 app.register_blueprint(web_api_deployer.bp)
 app.register_blueprint(swagger_ui_blueprint.bp, url_prefix=swagger_ui_blueprint.SWAGGER_URL)
 app.register_blueprint(web_api_metrics.bp)

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_web/blueprints/snode_ops_k8s.py

@@ -336,14 +336,24 @@ def spdk_process_start(body: SPDKParams):
         spdk_process_kill(query)
 
     node_prepration_job_name = "snode-spdk-job-"
+    node_prepration_core_name = "snode-spdk-core-isolate-"
     node_name = os.environ.get("HOSTNAME", "")
-
+    core_isolate = os.environ.get("CORE_ISOLATION", False)
+    if isinstance(core_isolate, str):
+       core_isolate = core_isolate.strip().lower() in ("true")
+    
     # limit the job name length to 63 characters
     k8s_job_name_length = len(node_prepration_job_name+node_name)
+    core_name_length = len(node_prepration_core_name+node_name)
     if k8s_job_name_length > 63:
         node_prepration_job_name += node_name[k8s_job_name_length-63:]
     else:
         node_prepration_job_name += node_name
+        
+    if core_name_length > 63:
+        node_prepration_core_name += node_name[core_name_length-63:]
+    else:
+         node_prepration_core_name += node_name
 
     logger.debug(f"deploying k8s job to prepare worker: {node_name}")
 
@@ -361,6 +371,7 @@ def spdk_process_start(body: SPDKParams):
             'RPC_PASSWORD': body.rpc_password,
             'HOSTNAME': node_name,
             'JOBNAME': node_prepration_job_name,
+            'CORE_JOBNAME': node_prepration_core_name,
             'NAMESPACE': namespace,
             'FDB_CONNECTION': body.fdb_connection,
             'SIMPLYBLOCK_DOCKER_IMAGE': constants.SIMPLY_BLOCK_DOCKER_IMAGE,
@@ -390,6 +401,27 @@ def spdk_process_start(body: SPDKParams):
         )
         logger.info(f"Job deleted: '{job_resp.metadata.name}' in namespace '{namespace}")
 
+        if core_isolate:
+            core_template = env.get_template('storage_core_isolation.yaml.j2')
+            core_yaml = yaml.safe_load(core_template.render(values))
+            batch_v1 = core_utils.get_k8s_batch_client()
+            core_resp = batch_v1.create_namespaced_job(namespace=namespace, body=core_yaml)
+            msg = f"Job created: '{core_resp.metadata.name}' in namespace '{namespace}"
+            logger.info(msg)
+
+            node_utils_k8s.wait_for_job_completion(core_resp.metadata.name, namespace)
+            logger.info(f"Job '{core_resp.metadata.name}' completed successfully")
+
+            batch_v1.delete_namespaced_job(
+                name=core_resp.metadata.name,
+                namespace=namespace,
+                body=V1DeleteOptions(
+                    propagation_policy='Foreground',
+                    grace_period_seconds=0
+                )
+            )
+            logger.info(f"Job deleted: '{core_resp.metadata.name}' in namespace '{namespace}")
+
         env = Environment(loader=FileSystemLoader(os.path.join(TOP_DIR, 'templates')), trim_blocks=True, lstrip_blocks=True)
         template = env.get_template('storage_deploy_spdk.yaml.j2')
         dep = yaml.safe_load(template.render(values))

{sbcli_dev-19.2.3 → sbcli_dev-19.2.5}/simplyblock_web/blueprints/web_api_lvol.py

@@ -49,12 +49,6 @@ def lvol_iostats(uuid, history):
     if not lvol:
         return utils.get_response_error(f"LVol not found: {uuid}", 404)
 
-    pool = db.get_pool_by_id(lvol.pool_uuid)
-    if pool.secret:
-        req_secret = request.headers.get('secret', "")
-        if req_secret != pool.secret:
-            return utils.get_response_error("Pool secret doesn't mach the value in the request header", 400)
-
     data = lvol_controller.get_io_stats(uuid, history, parse_sizes=False, with_sizes=True)
     ret = {
         "object_data": lvol.get_clean_dict(),
@@ -69,12 +63,6 @@ def lvol_capacity(uuid, history):
     if not lvol:
         return utils.get_response_error(f"LVol not found: {uuid}", 404)
 
-    pool = db.get_pool_by_id(lvol.pool_uuid)
-    if pool.secret:
-        req_secret = request.headers.get('secret', "")
-        if req_secret != pool.secret:
-            return utils.get_response_error("Pool secret doesn't mach the value in the request header", 400)
-
     data = lvol_controller.get_capacity(uuid, history, parse_sizes=False)
     out = []
     if data: