sbcli-dev 17.3.3__tar.gz → 17.3.5__tar.gz

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/PKG-INFO

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

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/sbcli_dev.egg-info/PKG-INFO

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

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/sbcli_dev.egg-info/SOURCES.txt

@@ -50,6 +50,7 @@ simplyblock_core/models/caching_node.py
 simplyblock_core/models/cluster.py
 simplyblock_core/models/deployer.py
 simplyblock_core/models/events.py
+simplyblock_core/models/hublvol.py
 simplyblock_core/models/iface.py
 simplyblock_core/models/job_schedule.py
 simplyblock_core/models/lvol_model.py

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/simplyblock_core/controllers/lvol_controller.py

@@ -23,14 +23,6 @@ from simplyblock_core.snode_client import SNodeClient
 logger = lg.getLogger()
 
 
-def _generate_hex_string(length):
-    def _generate_string(length):
-        return ''.join(random.SystemRandom().choice(
-            string.ascii_letters + string.digits) for _ in range(length))
-
-    return _generate_string(length).encode('utf-8').hex()
-
-
 def _create_crypto_lvol(rpc_client, name, base_name, key1, key2):
     key_name = f'key_{name}'
     ret = rpc_client.lvol_crypto_key_create(key_name, key1, key2)
@@ -427,7 +419,7 @@ def add_lvol_ha(name, size, host_id_or_name, ha_type, pool_id_or_name, use_comp,
     lvol.ha_type = ha_type
     lvol.bdev_stack = []
     lvol.uuid = uid or str(uuid.uuid4())
-    lvol.guid = _generate_hex_string(16)
+    lvol.guid = utils.generate_hex_string(16)
     lvol.vuid = vuid
     lvol.lvol_bdev = f"LVOL_{vuid}"
 

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/simplyblock_core/controllers/snapshot_controller.py

@@ -439,7 +439,7 @@ def clone(snapshot_id, clone_name, new_size=0):
     lvol.pool_uuid = pool.get_id()
     lvol.ha_type = snap.lvol.ha_type
     lvol.lvol_type = 'lvol'
-    lvol.guid = lvol_controller._generate_hex_string(16)
+    lvol.guid = utils.generate_hex_string(16)
     lvol.vuid = snap.lvol.vuid
     lvol.snapshot_name = snap.snap_bdev
     lvol.subsys_port = snap.lvol.subsys_port

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/simplyblock_core/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=17.3.3
+SIMPLY_BLOCK_VERSION=17.3.5
 
 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-17.3.3 → sbcli_dev-17.3.5}/simplyblock_core/models/base_model.py

@@ -1,5 +1,6 @@
 # coding=utf-8
 import pprint
+import logging
 
 import json
 from inspect import ismethod
@@ -115,8 +116,10 @@ class BaseModel(object):
             for k, v in kv_store.get_range_startswith(prefix.strip().encode('utf-8'),  limit=limit, reverse=reverse):
                 objects.append(self.__class__().from_dict(json.loads(v)))
             return objects
-        except Exception as e:
-            print(f"Error reading from FDB: {e}")
+        except Exception:
+            from simplyblock_core import utils
+            logger = utils.get_logger(__name__)
+            logger.exception('Error reading from FDB')
             return []
 
     def get_last(self, kv_store):

sbcli_dev-17.3.5/simplyblock_core/models/hublvol.py

@@ -0,0 +1,12 @@
+# coding=utf-8
+
+from simplyblock_core.models.base_model import BaseModel
+
+
+class HubLVol(BaseModel):
+    """Identifying information of a HubLVol
+    """
+    uuid: str = ""
+    nqn: str = ""
+    name: str = ""
+    nvmf_port: int = 9099

sbcli_dev-17.3.5/simplyblock_core/models/storage_node.py

@@ -0,0 +1,211 @@
+# coding=utf-8
+
+from typing import List
+from uuid import uuid4
+
+from simplyblock_core import utils
+from simplyblock_core.models.base_model import BaseNodeObject
+from simplyblock_core.models.hublvol import HubLVol
+from simplyblock_core.models.iface import IFace
+from simplyblock_core.models.nvme_device import NVMeDevice, JMDevice
+from simplyblock_core.rpc_client import RPCClient, RPCException
+
+logger = utils.get_logger(__name__)
+
+
+class StorageNode(BaseNodeObject):
+
+    alceml_cpu_cores: List[int] = []
+    alceml_cpu_index: int = 0
+    alceml_worker_cpu_cores: List[int] = []
+    alceml_worker_cpu_index: int = 0
+    api_endpoint: str = ""
+    app_thread_mask: str = ""
+    baseboard_sn: str = ""
+    cloud_instance_id: str = ""
+    cloud_instance_public_ip: str = ""
+    cloud_instance_type: str = ""
+    cloud_name: str = ""
+    cluster_id: str = ""
+    cpu: int = 0
+    cpu_hz: int = 0
+    ctrl_secret: str = ""
+    data_nics: List[IFace] = []
+    distrib_cpu_cores: List[int] = []
+    distrib_cpu_index: int = 0
+    distrib_cpu_mask: str = ""
+    enable_ha_jm: bool = False
+    ha_jm_count: int = 3
+    enable_test_device: bool = False
+    health_check: bool = True
+    host_nqn: str = ""
+    host_secret: str = ""
+    hostname: str = ""
+    hugepages: int = 0
+    ib_devices: List[IFace] = []
+    id_device_by_nqn: bool = False
+    iobuf_large_bufsize: int = 0
+    iobuf_large_pool_count: int = 0
+    iobuf_small_bufsize: int = 0
+    iobuf_small_pool_count: int = 0
+    is_secondary_node: bool = False
+    jc_singleton_mask: str = ""
+    jm_cpu_mask: str = ""
+    jm_device: JMDevice = None
+    jm_percent: int = 3
+    jm_vuid: int = 0
+    lvols: int = 0
+    lvstore: str = ""
+    lvstore_stack: List[dict] = []
+    lvstore_stack_secondary_1: List[dict] = []
+    lvstore_stack_secondary_2: List[dict] = []
+    lvol_subsys_port: int = 9090
+    max_lvol: int = 0
+    max_prov: int = 0
+    max_snap: int = 0
+    memory: int = 0
+    mgmt_ip: str = ""
+    namespace: str = ""
+    node_lvs: str = "lvs"
+    num_partitions_per_dev: int = 1
+    number_of_devices: int = 0
+    number_of_distribs: int = 4
+    nvme_devices: List[NVMeDevice] = []
+    online_since: str = ""
+    partitions_count: int = 0  # Unused
+    poller_cpu_cores: List[int] = []
+    ssd_pcie: List = []
+    pollers_mask: str = ""
+    primary_ip: str = ""
+    raid: str = ""
+    remote_devices: List[NVMeDevice] = []
+    remote_jm_devices: List[JMDevice] = []
+    rpc_password: str = ""
+    rpc_port: int = -1
+    rpc_username: str = ""
+    secondary_node_id: str = ""
+    sequential_number: int = 0  # Unused
+    jm_ids: List[str] = []
+    spdk_cpu_mask: str = ""
+    spdk_debug: bool = False
+    spdk_image: str = ""
+    spdk_mem: int = 0
+    partition_size: int = 0
+    subsystem: str = ""
+    system_uuid: str = ""
+    lvstore_status: str = ""
+    nvmf_port: int = 4420
+    physical_label: int = 0
+    hublvol: HubLVol = None
+
+    def rpc_client(self, **kwargs):
+        """Return rpc client to this node
+        """
+        return RPCClient(
+            self.mgmt_ip, self.rpc_port,
+            self.rpc_username, self.rpc_password, **kwargs)
+
+    def expose_bdev(self, nqn, bdev_name, model_number, uuid, nguid, port):
+        rpc_client = self.rpc_client()
+
+        try:
+            if not rpc_client.subsystem_create(
+                    nqn=nqn,
+                    serial_number='sbcli-cn',
+                    model_number=model_number,
+            ):
+                raise RPCException(f'Failed to create subsystem for {nqn}')
+
+            for ip in (iface.ip4_address for iface in self.data_nics):
+                if not rpc_client.listeners_create(
+                        nqn=nqn,
+                        trtype='TCP',
+                        traddr=ip,
+                        trsvcid=port,
+                ):
+                    raise RPCException(f'Failed to create listener for {nqn}')
+
+            if not rpc_client.nvmf_subsystem_add_ns(
+                    nqn=nqn,
+                    dev_name=bdev_name,
+                    uuid=uuid,
+                    nguid=nguid,
+            ):
+                raise RPCException(f'Failed to add namespace to subsytem {nqn}')
+        except RPCException:
+            if self.hublvol and rpc_client.subsystem_list(self.hublvol.nqn):
+                rpc_client.subsystem_delete(self.hublvol.nqn)
+
+            raise
+
+    def create_hublvol(self, cluster_nqn):
+        """Create a hublvol for this node's lvstore
+        """
+        logger.info(f'Creating hublvol on {self.get_id()}')
+        rpc_client = self.rpc_client()
+
+        hublvol_uuid = None
+        try:
+            hublvol_uuid = rpc_client.bdev_lvol_create_hublvol(self.lvstore)
+            if not hublvol_uuid:
+                raise RPCException('Failed to create hublvol')
+            self.hublvol = HubLVol({
+                'uuid': hublvol_uuid,
+                'nqn': f'{cluster_nqn}:lvol:{hublvol_uuid}',
+                'name': f'{self.lvstore}/hublvol',
+            })
+
+            self.expose_bdev(
+                    nqn=self.hublvol.nqn,
+                    bdev_name=self.hublvol.name,
+                    model_number=str(uuid4()),
+                    uuid=self.hublvol.uuid,
+                    nguid=utils.generate_hex_string(16),
+                    port=self.hublvol.nvmf_port
+            )
+        except RPCException:
+            if hublvol_uuid is not None and rpc_client.get_bdevs(hublvol_uuid):
+                rpc_client.bdev_lvol_delete_hublvol(self.hublvol.nqn)
+
+            if self.hublvol and rpc_client.subsystem_list(self.hublvol.nqn):
+                rpc_client.subsystem_delete(self.hublvol.nqn)
+                self.hublvol = None
+
+            raise
+
+        self.write_to_db()
+        return self.hublvol
+
+    def connect_to_hublvol(self, primary_node):
+        """Connect to a primary node's hublvol
+        """
+        logger.info(f'Connecting node {self.get_id()} to hublvol on {primary_node.get_id()}')
+
+        if primary_node.hublvol is None:
+            raise ValueError(f"HubLVol of primary node {primary_node.get_id()} is not present")
+
+        rpc_client = self.rpc_client()
+
+        remote_bdev = None
+        for ip in (iface.ip4_address for iface in primary_node.data_nics):
+            remote_bdev = rpc_client.bdev_nvme_attach_controller_tcp(
+                    primary_node.hublvol.name, primary_node.hublvol.nqn,
+                    ip, primary_node.hublvol.nvmf_port)[0]
+            if remote_bdev is not None:
+                break
+            else:
+                logger.warning(f'Failed to connect to hublvol on {ip}')
+
+        if remote_bdev is None:
+            raise RPCException('Failed to connect to hublvol')
+
+        if not rpc_client.bdev_lvol_set_lvs_opts(
+                primary_node.lvstore,
+                groupid=primary_node.jm_vuid,
+                subsystem_port=self.lvol_subsys_port,
+                secondary=True,
+        ):
+            raise RPCException('Failed to set secondary lvstore options')
+
+        if not rpc_client.bdev_lvol_connect_hublvol(primary_node.lvstore, remote_bdev):
+            raise RPCException('Failed to connect secondary lvstore to primary')

{sbcli_dev-17.3.3 → sbcli_dev-17.3.5}/simplyblock_core/rpc_client.py

@@ -1,4 +1,5 @@
 import json
+import inspect
 
 import requests
 
@@ -913,18 +914,12 @@ class RPCClient:
             params = {"jm_vuid": jm_vuid}
         return self._request("bdev_distrib_force_to_non_leader", params)
 
-    def bdev_lvol_set_leader(self, is_leader=False, uuid=None, lvs_name=None, bs_nonleadership=False):
-        params = {
-            "lvs_leadership": is_leader,
-        }
-        if uuid:
-            params["uuid"] = uuid
-        elif lvs_name:
-            params["lvs_name"] = lvs_name
-
-        params["bs_nonleadership"] = bs_nonleadership
-
-        return self._request("bdev_lvol_set_leader_all", params)
+    def bdev_lvol_set_leader(self, lvs, *, leader=False, bs_nonleadership=False):
+        return self._request("bdev_lvol_set_leader_all", {
+            "uuid" if utils.UUID_PATTERN.match(lvs) else "lvs_name": lvs,
+            "lvs_leadership": leader,
+            "bs_nonleadership": bs_nonleadership,
+        })
 
     def bdev_lvol_register(self, name, lvs_name, registered_uuid, blobid, priority_class=0):
         params = {
@@ -982,13 +977,19 @@ class RPCClient:
         }
         return self._request("nvmf_set_max_subsystems", params)
 
-    def bdev_lvol_set_lvs_ops(self, lvs_name, groupid, subsystem_port=9090):
-        params = {
+    def bdev_lvol_set_lvs_opts(self, lvs, *, groupid, subsystem_port=9090, primary=False, secondary=False):
+        """Set lvstore options
+
+        `lvs` must be either an ID or the lvstore name.
+        """
+
+        return self._request(inspect.currentframe().f_code.co_name, {
+            "uuid" if utils.UUID_PATTERN.match(lvs) else "lvs_name": lvs,
             "groupid": groupid,
-            "lvs_name": lvs_name,
             "subsystem_port": subsystem_port,
-        }
-        return self._request("bdev_lvol_set_lvs_op", params)
+            "primary": primary,
+            "secondary": secondary,
+        })
 
     def bdev_lvol_get_lvol_delete_status(self, name):
         """
@@ -1010,3 +1011,18 @@ class RPCClient:
         }
         return self._request("bdev_lvol_set_lvs_read_only", params)
 
+    def bdev_lvol_create_hublvol(self, lvs):
+        return self._request(inspect.currentframe().f_code.co_name, {
+            "uuid" if utils.UUID_PATTERN.match(lvs) else "lvs_name": lvs,
+        })
+
+    def bdev_lvol_delete_hublvol(self, lvs):
+        return self._request(inspect.currentframe().f_code.co_name, {
+            "uuid" if utils.UUID_PATTERN.match(lvs) else "lvs_name": lvs,
+        })
+
+    def bdev_lvol_connect_hublvol(self, lvs, bdev):
+        return self._request(inspect.currentframe().f_code.co_name, {
+            "uuid" if utils.UUID_PATTERN.match(lvs) else "lvs_name": lvs,
+            "remote_bdev": bdev,
+        })