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

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

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

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

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

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

@@ -1080,8 +1080,9 @@ def list_lvols(is_json, cluster_id, pool_id_or_name, all=False):
     if cluster_id:
         lvols = db_controller.get_lvols(cluster_id)
     elif pool_id_or_name:
-        pool = db_controller.get_pool_by_id(pool_id_or_name)
-        if not pool:
+        try:
+            pool = db_controller.get_pool_by_id(pool_id_or_name)
+        except KeyError:
             pool = db_controller.get_pool_by_name(pool_id_or_name)
             if pool:
                 for lv in db_controller.get_lvols_by_pool_id(pool.get_id()):

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

@@ -105,8 +105,9 @@ def qos_exists_on_child_lvol(db_controller: DBController, pool_uuid):
 def set_pool(uuid, pool_max=0, lvol_max=0, max_rw_iops=0,
              max_rw_mbytes=0, max_r_mbytes=0, max_w_mbytes=0, name=""):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(uuid)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(uuid)
+    except KeyError:
         msg = f"Pool not found: {uuid}"
         logger.error(msg)
         return False, msg
@@ -167,8 +168,9 @@ def set_pool(uuid, pool_max=0, lvol_max=0, max_rw_iops=0,
 
 def delete_pool(uuid):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(uuid)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(uuid)
+    except KeyError:
         pool = db_controller.get_pool_by_name(uuid)
     if not pool:
         logger.error(f"Pool not found {uuid}")
@@ -214,9 +216,10 @@ def list_pools(is_json, cluster_id=None):
 
 def set_status(pool_id, status):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
     logger.info(f"Setting pool:{pool_id} status to Active")
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
     pool.status = status
@@ -226,8 +229,9 @@ def set_status(pool_id, status):
 
 def get_pool(pool_id, is_json):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
 
@@ -241,8 +245,9 @@ def get_pool(pool_id, is_json):
 
 def get_capacity(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
 
@@ -268,8 +273,9 @@ def get_capacity(pool_id):
 
 def get_io_stats(pool_id, history, records_count=20):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
 
@@ -300,8 +306,9 @@ def get_io_stats(pool_id, history, records_count=20):
 
 def get_secret(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
 
@@ -313,8 +320,9 @@ def get_secret(pool_id):
 
 def set_secret(pool_id, secret):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
 
@@ -328,8 +336,9 @@ def set_secret(pool_id, secret):
 
 def get_pool_total_capacity(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
     total = 0
@@ -345,8 +354,9 @@ def get_pool_total_capacity(pool_id):
 
 def get_pool_total_rw_iops(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
     if pool.max_rw_ios_per_sec <= 0:
@@ -361,8 +371,9 @@ def get_pool_total_rw_iops(pool_id):
 
 def get_pool_total_rw_mbytes(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
     if pool.max_rw_mbytes_per_sec <= 0:
@@ -377,8 +388,9 @@ def get_pool_total_rw_mbytes(pool_id):
 
 def get_pool_total_r_mbytes(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
     if pool.max_r_mbytes_per_sec <= 0:
@@ -393,8 +405,9 @@ def get_pool_total_r_mbytes(pool_id):
 
 def get_pool_total_w_mbytes(pool_id):
     db_controller = DBController()
-    pool = db_controller.get_pool_by_id(pool_id)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(pool_id)
+    except KeyError:
         logger.error(f"Pool not found {pool_id}")
         return False
     if pool.max_w_mbytes_per_sec <= 0:

{sbcli_dev-19.2.1 → sbcli_dev-19.2.3}/simplyblock_core/controllers/snapshot_controller.py

@@ -357,8 +357,9 @@ def clone(snapshot_id, clone_name, new_size=0, pvc_name=None, pvc_namespace=None
         logger.error(msg)
         return False, msg
 
-    pool = db_controller.get_pool_by_id(snap.lvol.pool_uuid)
-    if not pool:
+    try:
+        pool = db_controller.get_pool_by_id(snap.lvol.pool_uuid)
+    except KeyError:
         msg=f"Pool not found: {snap.lvol.pool_uuid}"
         logger.error(msg)
         return False, msg

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

@@ -145,11 +145,11 @@ class DBController(metaclass=Singleton):
             pools = Pool().read_from_db(self.kv_store)
         return pools
 
-    def get_pool_by_id(self, id) -> Optional[Pool]:
+    def get_pool_by_id(self, id) -> Pool:
         ret = Pool().read_from_db(self.kv_store, id)
-        if ret:
-            return ret[0]
-        return None
+        if not ret:
+            raise KeyError(f'Pool {id} not found')
+        return ret[0]
 
     def get_pool_by_name(self, name) -> Optional[Pool]:
         pools = Pool().read_from_db(self.kv_store)

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

@@ -1,7 +1,7 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=19.2.1
+SIMPLY_BLOCK_VERSION=19.2.3
 
 
-SIMPLY_BLOCK_DOCKER_IMAGE=public.ecr.aws/simply-block/simplyblock:multi_sn_k8s_worker
+SIMPLY_BLOCK_DOCKER_IMAGE=public.ecr.aws/simply-block/simplyblock:main
 
 SIMPLY_BLOCK_SPDK_ULTRA_IMAGE=public.ecr.aws/simply-block/ultra:main-latest

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

@@ -152,30 +152,28 @@ while True:
                     if org_dev.status == NVMeDevice.STATUS_ONLINE and org_node.status == StorageNode.STATUS_ONLINE:
                         if health_controller.check_bdev(remote_device.remote_bdev, bdev_names=node_bdev_names):
                             connected_devices.append(remote_device.get_id())
-                            ret = True
-                        else:
-                            if not org_dev.alceml_bdev:
-                                logger.error(f"device alceml bdev not found!, {org_dev.get_id()}")
-                                continue
-                            name = f"remote_{org_dev.alceml_bdev}"
-                            logger.info(f"Connecting {name} to {snode.get_id()}")
-                            ret = rpc_client.bdev_nvme_attach_controller_tcp(
-                                name, org_dev.nvmf_nqn, org_dev.nvmf_ip, org_dev.nvmf_port)
-                            if ret:
-                                logger.info(f"Successfully connected to device: {org_dev.get_id()}")
-                                connected_devices.append(org_dev.get_id())
-                                sn = db.get_storage_node_by_id(snode.get_id())
-                                for d in sn.remote_devices:
-                                    if d.get_id() == remote_device.get_id():
-                                        d.status = NVMeDevice.STATUS_ONLINE
-                                        sn.write_to_db()
-                                        break
-
-                                distr_controller.send_dev_status_event(org_dev, NVMeDevice.STATUS_ONLINE, snode)
-                            else:
-                                logger.error(f"Failed to connect to device: {org_dev.get_id()}")
-
-                        node_remote_devices_check &= bool(ret)
+                            continue
+
+                        if not org_dev.alceml_bdev:
+                            logger.error(f"device alceml bdev not found!, {org_dev.get_id()}")
+                            continue
+
+                        try:
+                            storage_node_ops.connect_device(
+                                    f"remote_{org_dev.alceml_bdev}", org_dev, rpc_client,
+                                    bdev_names=list(node_bdev_names), reattach=False,
+                            )
+                            connected_devices.append(org_dev.get_id())
+                            sn = db.get_storage_node_by_id(snode.get_id())
+                            for d in sn.remote_devices:
+                                if d.get_id() == remote_device.get_id():
+                                    d.status = NVMeDevice.STATUS_ONLINE
+                                    sn.write_to_db()
+                                    break
+                            distr_controller.send_dev_status_event(org_dev, NVMeDevice.STATUS_ONLINE, snode)
+                        except RuntimeError:
+                            logger.error(f"Failed to connect to device: {org_dev.get_id()}")
+                            node_remote_devices_check = False
 
                 connected_jms = []
                 if snode.jm_device and snode.jm_device.get_id():

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

@@ -7,6 +7,7 @@ from simplyblock_core.controllers import tasks_events, tcp_ports_events, health_
 from simplyblock_core.fw_api_client import FirewallClient
 from simplyblock_core.models.job_schedule import JobSchedule
 from simplyblock_core.models.cluster import Cluster
+from simplyblock_core.models.nvme_device import NVMeDevice
 from simplyblock_core.models.storage_node import StorageNode
 from simplyblock_core.snode_client import SNodeClient
 
@@ -58,10 +59,67 @@ while True:
                             task.write_to_db(db.kv_store)
                             continue
 
-                        logger.info("connecting remote devices")
-                        node.remote_devices = storage_node_ops._connect_to_remote_devs(
-                            node, force_conect_restarting_nodes=True)
-                        node.write_to_db()
+                        # check node ping
+                        ping_check = health_controller._check_node_ping(node.mgmt_ip)
+                        logger.info(f"Check: ping mgmt ip {node.mgmt_ip} ... {ping_check}")
+                        if not ping_check:
+                            time.sleep(1)
+                            ping_check = health_controller._check_node_ping(node.mgmt_ip)
+                            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"
+                            logger.info(msg)
+                            task.function_result = msg
+                            task.status = JobSchedule.STATUS_SUSPENDED
+                            task.write_to_db(db.kv_store)
+                            continue
+
+                        # check node ping
+                        logger.info("connect to remote devices")
+                        nodes = db.get_storage_nodes_by_cluster_id(node.cluster_id)
+                        # connect to remote devs
+                        try:
+                            remote_devices = []
+                            for nd in nodes:
+                                if nd.get_id() == node.get_id() or nd.status not in [StorageNode.STATUS_ONLINE, StorageNode.STATUS_DOWN]:
+                                    continue
+                                logger.info(f"Connecting to node {nd.get_id()}")
+                                for index, dev in enumerate(nd.nvme_devices):
+
+                                    if dev.status not in [NVMeDevice.STATUS_ONLINE, NVMeDevice.STATUS_READONLY,
+                                                          NVMeDevice.STATUS_CANNOT_ALLOCATE]:
+                                        logger.debug(f"Device is not online: {dev.get_id()}, status: {dev.status}")
+                                        continue
+
+                                    if not dev.alceml_bdev:
+                                        raise ValueError(f"device alceml bdev not found!, {dev.get_id()}")
+
+                                    dev.remote_bdev = storage_node_ops.connect_device(
+                                        f"remote_{dev.alceml_bdev}", dev, node.rpc_client(),
+                                        bdev_names=[], reattach=False)
+
+                                    remote_devices.append(dev)
+                            if remote_devices:
+                                node = db.get_storage_node_by_id(task.node_id)
+                                node.remote_devices = remote_devices
+                                node.write_to_db()
+                            else:
+                                msg = f"Node unable to connect to remote devs, retry task"
+                                logger.info(msg)
+                                task.function_result = msg
+                                task.status = JobSchedule.STATUS_SUSPENDED
+                                task.write_to_db(db.kv_store)
+                                continue
+
+                        except Exception as e:
+                            logger.error(e)
+                            msg = f"Error when connect to remote devs, retry task"
+                            logger.info(msg)
+                            task.function_result = msg
+                            task.status = JobSchedule.STATUS_SUSPENDED
+                            task.write_to_db(db.kv_store)
+                            continue
 
                         logger.info("Sending device status event")
                         for db_dev in node.nvme_devices:

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

@@ -2,6 +2,7 @@
 import datetime
 import json
 import os
+from typing import List
 
 import threading
 
@@ -34,6 +35,39 @@ from simplyblock_core.utils import pull_docker_image_with_retry
 logger = utils.get_logger(__name__)
 
 
+def connect_device(name: str, device: NVMeDevice, rpc_client: RPCClient, bdev_names: List[str], reattach: bool):
+    """Connect snode to device
+
+    This only performs the actual operation between both involved SPDK instances,
+    no book-keeping is done here.
+
+    More sensibly this would be a member function of either StorageNode or NVMeDevice.
+    """
+
+    logger.info(f'Connecting to {name}')
+    bdev_name = f"{name}n1"
+    if bdev_name in bdev_names:
+        logger.debug("Already connected")
+        return bdev_name
+
+    if reattach and rpc_client.bdev_nvme_controller_list(name):
+        rpc_client.bdev_nvme_detach_controller(name)
+        time.sleep(1)
+
+    for ip in device.nvmf_ip.split(","):
+        rpc_client.bdev_nvme_attach_controller_tcp(
+                name, device.nvmf_nqn, ip, device.nvmf_port,
+                multipath=device.nvmf_multipath,
+        )
+        if device.nvmf_multipath:
+            rpc_client.bdev_nvme_set_multipath_policy(bdev_name, "active_active")
+
+    if not rpc_client.get_bdevs(bdev_name):
+        raise RuntimeError(f"Failed to connect to device: {device.get_id()}")
+
+    return bdev_name
+
+
 def get_next_cluster_device_order(db_controller, cluster_id):
     max_order = 0
     found = False
@@ -629,32 +663,12 @@ def _connect_to_remote_devs(this_node, force_conect_restarting_nodes=False):
                 continue
 
             if not dev.alceml_bdev:
-                logger.error(f"device alceml bdev not found!, {dev.get_id()}")
-                continue
-            name = f"remote_{dev.alceml_bdev}"
-            bdev_name = f"{name}n1"
-            if bdev_name in node_bdev_names:
-                logger.info(f"bdev found {bdev_name}")
-            else:
-                # if rpc_client.bdev_nvme_controller_list(name):
-                #     logger.info(f"detaching {name} from {this_node.get_id()}")
-                #     rpc_client.bdev_nvme_detach_controller(name)
-                #     time.sleep(1)
-                if dev.nvmf_multipath:
-                    for ip in dev.nvmf_ip.split(","):
-                        logger.info(f"Connecting {name} to {this_node.get_id()}")
-                        rpc_client.bdev_nvme_attach_controller_tcp(
-                            name, dev.nvmf_nqn, ip, dev.nvmf_port, multipath=True)
-                        rpc_client.bdev_nvme_set_multipath_policy(bdev_name, "active_active")
-                else:
-                    logger.info(f"Connecting {name} to {this_node.get_id()}")
-                    rpc_client.bdev_nvme_attach_controller_tcp(
-                        name, dev.nvmf_nqn, dev.nvmf_ip, dev.nvmf_port, multipath=False)
-                ret = rpc_client.get_bdevs(bdev_name)
-                if not ret:
-                    logger.error(f"Failed to connect to device: {dev.get_id()}")
-                    continue
-            dev.remote_bdev = bdev_name
+                raise ValueError(f"device alceml bdev not found!, {dev.get_id()}")
+
+            dev.remote_bdev = connect_device(
+                    f"remote_{dev.alceml_bdev}", dev, rpc_client,
+                    bdev_names=node_bdev_names, reattach=False
+            )
             remote_devices.append(dev)
 
     return remote_devices
@@ -710,55 +724,18 @@ def _connect_to_remote_jm_devs(this_node, jm_ids=None):
         if not org_dev or org_dev in new_devs or org_dev_node.get_id() == this_node.get_id():
             continue
 
-        name = f"remote_{org_dev.jm_bdev}"
-        bdev_name = f"{name}n1"
-        org_dev.remote_bdev = bdev_name
-
-        if org_dev.status == NVMeDevice.STATUS_ONLINE:
-
-            if bdev_name in node_bdev_names:
-                logger.debug(f"bdev found {bdev_name}")
-                org_dev.status = JMDevice.STATUS_ONLINE
-                new_devs.append(org_dev)
-            elif org_dev_node.status == StorageNode.STATUS_ONLINE:
-                if rpc_client.bdev_nvme_controller_list(name):
-                    logger.info(f"detaching {name} from {this_node.get_id()}")
-                    rpc_client.bdev_nvme_detach_controller(name)
-                    time.sleep(1)
-
-                if org_dev.nvmf_multipath:
-                    for ip in org_dev.nvmf_ip.split(","):
-                        logger.info(f"Connecting {name} to {this_node.get_id()}")
-                        ret = rpc_client.bdev_nvme_attach_controller_tcp(
-                            name, org_dev.nvmf_nqn, ip, org_dev.nvmf_port, multipath=True)
-                        rpc_client.bdev_nvme_set_multipath_policy(bdev_name, "active_active")
-
-                    # if ret:
-                    org_dev.status = JMDevice.STATUS_ONLINE
-                    # else:
-                    #     logger.error(f"failed to connect to remote JM {name}")
-                    #     org_dev.status = JMDevice.STATUS_UNAVAILABLE
-                else:
-                    logger.info(f"Connecting {name} to {this_node.get_id()}")
-                    ret = rpc_client.bdev_nvme_attach_controller_tcp(
-                        name, org_dev.nvmf_nqn, org_dev.nvmf_ip, org_dev.nvmf_port, multipath=False)
-                    if ret:
-                        org_dev.status = JMDevice.STATUS_ONLINE
-                    else:
-                        logger.error(f"failed to connect to remote JM {name}")
-                        org_dev.status = JMDevice.STATUS_UNAVAILABLE
-                new_devs.append(org_dev)
-            else:
-                org_dev.status = JMDevice.STATUS_UNAVAILABLE
-                new_devs.append(org_dev)
-
-        else:
-            # if bdev_name in node_bdev_names:
-            #     logger.debug(f"bdev found {bdev_name}")
-            #     rpc_client.bdev_nvme_detach_controller(name)
-
+        if org_dev.status != NVMeDevice.STATUS_ONLINE or  org_dev_node.status != StorageNode.STATUS_ONLINE:
             org_dev.status = JMDevice.STATUS_UNAVAILABLE
-            new_devs.append(org_dev)
+        else:
+            try:
+                org_dev.remote_bdev = connect_device(
+                        f"remote_{org_dev.jm_bdev}", org_dev, rpc_client,
+                        bdev_names=node_bdev_names, reattach=True,
+                )
+            except RuntimeError:
+                logger.error(f'Failed to connect to {org_dev.get_id()}')
+                org_dev.status = JMDevice.STATUS_UNAVAILABLE
+        new_devs.append(org_dev)
 
     return new_devs
 
@@ -1197,7 +1174,11 @@ def add_node(cluster_id, node_addr, iface_name, data_nics_list,
         for node in snodes:
             if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
                 continue
-            node.remote_devices = _connect_to_remote_devs(node)
+            try:
+                node.remote_devices = _connect_to_remote_devs(node)
+            except RuntimeError:
+                logger.error('Failed to connect to remote devices')
+                return False
             node.write_to_db(kv_store)
 
         if cluster.status not in [Cluster.STATUS_ACTIVE, Cluster.STATUS_DEGRADED, Cluster.STATUS_READONLY, Cluster.STATUS_IN_EXPANSION]:
@@ -1741,7 +1722,11 @@ def restart_storage_node(
     snode.write_to_db()
 
     logger.info("Connecting to remote devices")
-    snode.remote_devices = _connect_to_remote_devs(snode)
+    try:
+        snode.remote_devices = _connect_to_remote_devs(snode)
+    except RuntimeError:
+        logger.error('Failed to connect to remote devices')
+        return False
     if snode.enable_ha_jm:
         snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
     snode.health_check = True
@@ -1784,7 +1769,11 @@ def restart_storage_node(
         for node in snodes:
             if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
                 continue
-            node.remote_devices = _connect_to_remote_devs(node, force_conect_restarting_nodes=True)
+            try:
+                node.remote_devices = _connect_to_remote_devs(node, force_conect_restarting_nodes=True)
+            except RuntimeError:
+                logger.error('Failed to connect to remote devices')
+                return False
             node.write_to_db(kv_store)
 
         logger.info("Sending device status event")
@@ -1826,8 +1815,14 @@ def restart_storage_node(
             for node in snodes:
                 if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
                     continue
-                node.remote_devices = _connect_to_remote_devs(node, force_conect_restarting_nodes=True)
+
+                try:
+                    node.remote_devices = _connect_to_remote_devs(node, force_conect_restarting_nodes=True)
+                except RuntimeError:
+                    logger.error('Failed to connect to remote devices')
+                    return False
                 node.write_to_db(kv_store)
+                    
 
             logger.info("Sending device status event")
             snode = db_controller.get_storage_node_by_id(snode.get_id())
@@ -2263,7 +2258,12 @@ def resume_storage_node(node_id):
 
     logger.info("Connecting to remote devices")
     snode = db_controller.get_storage_node_by_id(node_id)
-    snode.remote_devices = _connect_to_remote_devs(snode)
+    try:
+        snode.remote_devices = _connect_to_remote_devs(snode)
+    except RuntimeError:
+        logger.error('Failed to connect to remote devices')
+        return False
+
     if snode.enable_ha_jm:
         snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
 
@@ -2831,7 +2831,11 @@ def set_node_status(node_id, status, reconnect_on_online=True):
     if snode.status == StorageNode.STATUS_ONLINE and reconnect_on_online:
         snode = db_controller.get_storage_node_by_id(node_id)
         logger.info("Connecting to remote devices")
-        snode.remote_devices = _connect_to_remote_devs(snode)
+        try:
+            snode.remote_devices = _connect_to_remote_devs(snode)
+        except RuntimeError:
+            logger.error('Failed to connect to remote devices')
+            return False
         if snode.enable_ha_jm:
             snode.remote_jm_devices = _connect_to_remote_jm_devs(snode)
         snode.health_check = True
@@ -3051,11 +3055,11 @@ def recreate_lvstore(snode, force=False):
                 _kill_app()
                 raise Exception("Failed to recover lvstore")
 
-    logger.info("Suspending JC compression")
-    ret = rpc_client.jc_suspend_compression(jm_vuid=snode.jm_vuid, suspend=True)
-    if not ret:
-        logger.error("Failed to suspend JC compression")
-        # return False
+    # logger.info("Suspending JC compression")
+    # ret = rpc_client.jc_suspend_compression(jm_vuid=snode.jm_vuid, suspend=True)
+    # if not ret:
+    #     logger.error("Failed to suspend JC compression")
+    #     # return False
 
     ret = rpc_client.bdev_lvol_set_lvs_opts(
         snode.lvstore,

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

@@ -437,7 +437,7 @@ def spdk_process_kill(query: utils.RPCPortParams):
 
 
 def _is_pod_up(rpc_port):
-    k8s_core_v1 = node_utils_k8s.get_k8s_core_client()
+    k8s_core_v1 = core_utils.get_k8s_core_client()
     pod_name = f"snode-spdk-pod-{rpc_port}"
     try:
         resp = k8s_core_v1.list_namespaced_pod(node_utils_k8s.get_namespace())

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

@@ -234,9 +234,10 @@ def delete_lvol(uuid):
     if not lvol:
         return utils.get_response_error(f"LVol not found: {uuid}", 404)
 
-    pool = db.get_pool_by_id(lvol.pool_uuid)
-    if not pool:
-        return utils.get_response_error(f"Pool not found: {uuid}", 404)
+    try:
+        pool = db.get_pool_by_id(lvol.pool_uuid)
+    except KeyError:
+        return utils.get_response_error(f"Pool not found: {lvol.pool_uuid}", 404)
 
     if pool.status == pool.STATUS_INACTIVE:
         return utils.get_response_error("Pool is disabled", 400)