sbcli-dev 18.0.0__tar.gz → 18.0.2__tar.gz

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/PKG-INFO

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

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/simplyblock_core/db_controller.py

@@ -3,7 +3,7 @@ import logging
 import os.path
 
 import fdb
-from typing import List
+from typing import List, Optional
 
 from simplyblock_core import constants
 from simplyblock_core.models.caching_node import CachingNode
@@ -65,6 +65,13 @@ class DBController(metaclass=Singleton):
                 nodes.append(n)
         return sorted(nodes, key=lambda x: x.create_dt)
 
+    def get_storage_node_by_system_id(self, system_id) -> Optional[StorageNode]:
+        nodes = StorageNode().read_from_db(self.kv_store)
+        for node in nodes:
+            if node.system_uuid == system_id:
+                return node
+        return None
+
     def get_storage_nodes_by_system_id(self, system_id) -> List[StorageNode]:
         return [
             node for node
@@ -79,10 +86,11 @@ class DBController(metaclass=Singleton):
             if node.hostname == hostname
         ]
 
-    def get_storage_node_by_id(self, id) -> StorageNode:
+    def get_storage_node_by_id(self, id) -> Optional[StorageNode]:
         ret = StorageNode().read_from_db(self.kv_store, id)
         if ret:
             return ret[0]
+        return None
 
     # todo: change this function for multi cluster
     def get_caching_nodes(self) -> List[CachingNode]:
@@ -90,29 +98,40 @@ class DBController(metaclass=Singleton):
         ret = sorted(ret, key=lambda x: x.create_dt)
         return ret
 
-    def get_caching_node_by_id(self, id)  -> CachingNode:
+    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)  -> List[CachingNode]:
+    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)  -> CachingNode:
+    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:
+            if node.hostname == hostname:
+                return node
+        return None
 
-    def get_storage_device_by_id(self, id) -> NVMeDevice:
+    def get_storage_device_by_id(self, id) -> Optional[NVMeDevice]:
         nodes = self.get_storage_nodes()
         for node in nodes:
             for dev in node.nvme_devices:
                 if dev.get_id() == id:
                     return dev
+        return None
 
     def get_pools(self, cluster_id=None) -> List[Pool]:
         pools = []
@@ -124,16 +143,18 @@ class DBController(metaclass=Singleton):
             pools = Pool().read_from_db(self.kv_store)
         return pools
 
-    def get_pool_by_id(self, id) -> Pool:
+    def get_pool_by_id(self, id) -> Optional[Pool]:
         ret = Pool().read_from_db(self.kv_store, id)
         if ret:
             return ret[0]
+        return None
 
-    def get_pool_by_name(self, name) -> Pool:
+    def get_pool_by_name(self, name) -> Optional[Pool]:
         pools = Pool().read_from_db(self.kv_store)
         for pool in pools:
             if pool.pool_name == name:
                 return pool
+        return None
 
     def get_lvols(self, cluster_id=None) -> List[LVol]:
         lvols = self.get_all_lvols()
@@ -181,25 +202,29 @@ class DBController(metaclass=Singleton):
         ret = SnapShot().read_from_db(self.kv_store)
         return ret
 
-    def get_snapshot_by_id(self, id) -> SnapShot:
+    def get_snapshot_by_id(self, id) -> Optional[SnapShot]:
         ret = SnapShot().read_from_db(self.kv_store, id)
         if ret:
             return ret[0]
+        return None
 
-    def get_lvol_by_id(self, id) -> LVol:
+    def get_lvol_by_id(self, id) -> Optional[LVol]:
         lvols = LVol().read_from_db(self.kv_store, id=id)
         if lvols:
             return lvols[0]
+        return None
 
-    def get_lvol_by_name(self, lvol_name) -> LVol:
+    def get_lvol_by_name(self, lvol_name) -> Optional[LVol]:
         for lvol in self.get_lvols():
             if lvol.lvol_name == lvol_name:
                 return lvol
+        return None
 
-    def get_mgmt_node_by_id(self, id) -> MgmtNode:
+    def get_mgmt_node_by_id(self, id) -> Optional[MgmtNode]:
         ret = MgmtNode().read_from_db(self.kv_store, id)
         if ret:
             return ret[0]
+        return None
 
     def get_mgmt_nodes(self, cluster_id=None) -> List[MgmtNode]:
         nodes = MgmtNode().read_from_db(self.kv_store)
@@ -207,11 +232,12 @@ class DBController(metaclass=Singleton):
             nodes = [n for n in nodes if n.cluster_id == cluster_id]
         return sorted(nodes, key=lambda x: x.create_dt)
 
-    def get_mgmt_node_by_hostname(self, hostname) -> MgmtNode:
+    def get_mgmt_node_by_hostname(self, hostname) -> Optional[MgmtNode]:
         nodes = self.get_mgmt_nodes()
         for node in nodes:
             if node.hostname == hostname:
                 return node
+        return None
 
     def get_lvol_stats(self, lvol, limit=20) -> List[LVolStatObject]:
         if isinstance(lvol, str):
@@ -257,18 +283,20 @@ class DBController(metaclass=Singleton):
     def get_clusters(self) -> List[Cluster]:
         return Cluster().read_from_db(self.kv_store)
 
-    def get_cluster_by_id(self, cluster_id) -> Cluster:
+    def get_cluster_by_id(self, cluster_id) -> Optional[Cluster]:
         ret = Cluster().read_from_db(self.kv_store, id=cluster_id)
         if ret:
             return ret[0]
+        return None
 
     def get_deployers(self) -> List[Deployer]:
         return Deployer().read_from_db(self.kv_store)
 
-    def get_deployer_by_id(self, deployer_id) -> Deployer:
+    def get_deployer_by_id(self, deployer_id) -> Optional[Deployer]:
         ret = Deployer().read_from_db(self.kv_store, id=deployer_id)
         if ret:
             return ret[0]
+        return None
 
     def get_port_stats(self, node_id, port_id, limit=20) -> List[PortStat]:
         stats = PortStat().read_from_db(self.kv_store, id="%s/%s" % (node_id, port_id), limit=limit, reverse=True)
@@ -280,10 +308,11 @@ class DBController(metaclass=Singleton):
     def get_job_tasks(self, cluster_id, reverse=True, limit=0) -> List[JobSchedule]:
         return JobSchedule().read_from_db(self.kv_store, id=cluster_id, reverse=reverse, limit=limit)
 
-    def get_task_by_id(self, task_id) -> JobSchedule:
+    def get_task_by_id(self, task_id) -> Optional[JobSchedule]:
         for task in self.get_job_tasks(" "):
             if task.uuid == task_id:
                 return task
+        return None
 
     def get_snapshots_by_node_id(self, node_id) -> List[SnapShot]:
         ret = []
@@ -295,15 +324,15 @@ class DBController(metaclass=Singleton):
 
     def get_snode_size(self, node_id) -> int:
         snode = self.get_storage_node_by_id(node_id)
-        total_node_capacity = 0
-        for dev in snode.nvme_devices:
-            total_node_capacity += dev.size
-        return total_node_capacity
+        if snode is None:
+            raise KeyError('Node not found')
+        return sum(dev.size for dev in snode.nvme_devices)
 
-    def get_jm_device_by_id(self, jm_id) -> JMDevice:
+    def get_jm_device_by_id(self, jm_id) -> Optional[JMDevice]:
         for node in self.get_storage_nodes():
             if node.jm_device and node.jm_device.get_id() == jm_id:
                 return node.jm_device
+        return None
 
     def get_primary_storage_nodes_by_cluster_id(self, cluster_id) -> List[StorageNode]:
         ret = StorageNode().read_from_db(self.kv_store)

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/simplyblock_core/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=18.0.0
+SIMPLY_BLOCK_VERSION=18.0.2
 
 SIMPLY_BLOCK_DOCKER_IMAGE=public.ecr.aws/simply-block/simplyblock:main
-SIMPLY_BLOCK_SPDK_ULTRA_IMAGE=public.ecr.aws/simply-block/ultra:main-latest
+SIMPLY_BLOCK_SPDK_ULTRA_IMAGE=public.ecr.aws/simply-block/ultra:main-latest

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/simplyblock_core/models/hublvol.py

@@ -9,7 +9,7 @@ class HubLVol(BaseModel):
     uuid: str = ""
     nqn: str = ""
     bdev_name: str = ""
-    nvmf_port: int = 9096
+    nvmf_port: int = 9060
     model_number: str = ""
     nguid: str = ""
 

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/simplyblock_core/models/storage_node.py

@@ -162,7 +162,6 @@ class StorageNode(BaseNodeObject):
                 'bdev_name': f'{self.lvstore}/hublvol',
                 'model_number': str(uuid4()),
                 'nguid': utils.generate_hex_string(16),
-                'nvmf_port': utils.next_free_port(self.cluster_id),
                 'nvmf_port': utils.next_free_hublvol_port(self.cluster_id),
             })
 

{sbcli_dev-18.0.0 → sbcli_dev-18.0.2}/simplyblock_core/utils.py

@@ -1088,7 +1088,7 @@ def next_free_hublvol_port(cluster_id):
     from simplyblock_core.db_controller import DBController
     db_controller = DBController()
 
-    port = 9096
+    port = 9060
     used_ports = []
     for node in db_controller.get_storage_nodes_by_cluster_id(cluster_id):
         if node.hublvol and node.hublvol.nvmf_port > 0: