sbcli-pre 1.1.4__zip → 1.1.6__zip

{sbcli_pre-1.1.4 → sbcli_pre-1.1.6}/PKG-INFO

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

{sbcli_pre-1.1.4 → sbcli_pre-1.1.6}/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-pre
-SIMPLY_BLOCK_VERSION=1.1.4
+SIMPLY_BLOCK_VERSION=1.1.6
 
 SIMPLY_BLOCK_DOCKER_IMAGE=simplyblock/simplyblock:pre-release
 

{sbcli_pre-1.1.4 → sbcli_pre-1.1.6}/sbcli_pre.egg-info/PKG-INFO

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

{sbcli_pre-1.1.4 → sbcli_pre-1.1.6}/simplyblock_cli/cli.py

@@ -38,9 +38,9 @@ class CLIWrapper:
         sub_command.add_argument("cluster_id", help='UUID of the cluster to which the node will belong')
         sub_command.add_argument("node_ip", help='IP of storage node to add')
         sub_command.add_argument("ifname", help='Management interface name')
-        sub_command.add_argument("--partitions", help='Number of partitions to create per device', type=int, default=1)
+        sub_command.add_argument("--partitions", help='Number of partitions to create per device', type=int, default=0)
         sub_command.add_argument("--jm-percent", help='Number in percent to use for JM from each device',
-                                 type=int, default=3, dest='jm_percent')
+                                 type=int, default=0, dest='jm_percent')
         sub_command.add_argument("--data-nics", help='Data interface names', nargs='+', dest='data_nics')
         sub_command.add_argument("--memory", help='SPDK huge memory allocation, default is 4G', dest='spdk_mem')
         sub_command.add_argument("--spdk-image", help='SPDK image uri', dest='spdk_image')
@@ -630,9 +630,6 @@ class CLIWrapper:
             elif sub_command == "deploy-cleaner":
                 ret = storage_ops.deploy_cleaner()
 
-            elif sub_command == "add":
-                ret = self.storage_node_add(args)
-
             elif sub_command == "add-node":
                 cluster_id = args.cluster_id
                 node_ip = args.node_ip
@@ -1102,14 +1099,6 @@ class CLIWrapper:
         out = storage_ops.list_storage_nodes(self.db_store, args.json)
         return out
 
-    def storage_node_add(self, args):
-        cluster_id = args.cluster_id
-        ifname = args.ifname
-        data_nics = args.data_nics
-        # TODO: Validate the inputs
-        out = storage_ops.add_storage_node(cluster_id, ifname, data_nics)
-        return out
-
     def storage_node_list_devices(self, args):
         node_id = args.node_id
         sort = args.sort

{sbcli_pre-1.1.4 → sbcli_pre-1.1.6}/simplyblock_core/models/nvme_device.py

@@ -82,6 +82,7 @@ class JMDevice(BaseModel):
         "raid_bdev": {"type": str, 'default': ""},
         "alceml_bdev": {"type": str, 'default': ""},
         "jm_bdev": {"type": str, 'default': ""},
+        "nvme_device": {"type": NVMeDevice, 'default': None},
 
         "health_check": {"type": bool, "default": True},
         "io_error": {"type": bool, 'default': False},

{sbcli_pre-1.1.4 → sbcli_pre-1.1.6}/simplyblock_core/storage_node_ops.py

@@ -231,7 +231,7 @@ def _search_for_partitions(rpc_client, nvme_device):
     return partitioned_devices
 
 
-def _create_jm_device_stack(rpc_client, jm_nvme_bdevs, snode, after_restart):
+def _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart):
     raid_bdev = f"raid_jm_{snode.get_id()}"
     ret = rpc_client.bdev_raid_create(raid_bdev, jm_nvme_bdevs)
     if not ret:
@@ -265,6 +265,37 @@ def _create_jm_device_stack(rpc_client, jm_nvme_bdevs, snode, after_restart):
     })
 
 
+def _create_jm_stack_on_device(rpc_client, nvme, snode, after_restart):
+
+    alceml_id = nvme.get_id()
+    alceml_name = device_controller.get_alceml_name(alceml_id)
+    logger.info(f"adding {alceml_name}")
+
+    pba_init_mode = 3
+    if after_restart:
+        pba_init_mode = 2
+    ret = rpc_client.bdev_alceml_create(alceml_name, nvme.nvme_bdev, alceml_id, pba_init_mode=pba_init_mode)
+    if not ret:
+        logger.error(f"Failed to create alceml bdev: {alceml_name}")
+        return False
+
+    jm_bdev = f"jm_{snode.get_id()}"
+    ret = rpc_client.bdev_jm_create(jm_bdev, alceml_name)
+    if not ret:
+        logger.error(f"Failed to create {jm_bdev}")
+        return False
+
+    return JMDevice({
+        'uuid': str(uuid.uuid4()),
+        'device_name': jm_bdev,
+        'nvme_device': nvme,
+        'size': nvme.size,
+        'status': JMDevice.STATUS_ONLINE,
+        'alceml_bdev': alceml_name,
+        'jm_bdev': jm_bdev
+    })
+
+
 def _create_storage_device_stack(rpc_client, nvme, snode, after_restart):
     test_name = f"{nvme.nvme_bdev}_test"
     ret = rpc_client.bdev_passtest_create(test_name, nvme.nvme_bdev)
@@ -322,11 +353,8 @@ def _create_storage_device_stack(rpc_client, nvme, snode, after_restart):
     nvme.nvmf_ip = IP
     nvme.nvmf_port = 4420
     nvme.io_error = False
-    # old_status = nvme.status
     nvme.status = NVMeDevice.STATUS_ONLINE
     return nvme
-    # device_events.device_status_change(nvme, nvme.status, old_status)
-    # snode.write_to_db(db_controller.kv_store)
 
 
 def _create_device_partitions(rpc_client, nvme, snode):
@@ -354,7 +382,7 @@ def _create_device_partitions(rpc_client, nvme, snode):
     return True
 
 
-def _prepare_cluster_devices_2(snode, devices, after_restart=False):
+def _prepare_cluster_devices_partitions(snode, devices):
     db_controller = DBController()
     rpc_client = RPCClient(
         snode.mgmt_ip, snode.rpc_port,
@@ -374,9 +402,6 @@ def _prepare_cluster_devices_2(snode, devices, after_restart=False):
         logger.debug(partitioned_devices)
         if len(partitioned_devices) == (1 + snode.num_partitions_per_dev):
             logger.info("Partitioned devices found")
-        elif after_restart:
-            logger.error("Partitions count mismatch")
-            return False
         else:
             logger.info(f"Creating partitions for {nvme.nvme_bdev}")
             _create_device_partitions(rpc_client, nvme, snode)
@@ -390,7 +415,7 @@ def _prepare_cluster_devices_2(snode, devices, after_restart=False):
         jm_devices.append(partitioned_devices.pop(0))
 
         for dev in partitioned_devices:
-            new_device = _create_storage_device_stack(rpc_client, dev, snode, after_restart)
+            new_device = _create_storage_device_stack(rpc_client, dev, snode, after_restart=False)
             if not new_device:
                 logger.error("failed to create dev stack")
                 return False
@@ -403,7 +428,7 @@ def _prepare_cluster_devices_2(snode, devices, after_restart=False):
 
     if jm_devices:
         jm_nvme_bdevs = [dev.nvme_bdev for dev in jm_devices]
-        jm_device = _create_jm_device_stack(rpc_client, jm_nvme_bdevs, snode, after_restart)
+        jm_device = _create_jm_stack_on_raid(rpc_client, jm_nvme_bdevs, snode, after_restart=False)
         if not jm_device:
             logger.error(f"Failed to create JM device")
             return False
@@ -412,6 +437,49 @@ def _prepare_cluster_devices_2(snode, devices, after_restart=False):
     return True
 
 
+def _prepare_cluster_devices_jm_on_dev(snode, devices):
+    db_controller = DBController()
+
+    jm_device = devices[0]
+    # Set device cluster order
+    dev_order = get_next_cluster_device_order(db_controller, snode.cluster_id)
+    for index, nvme in enumerate(devices):
+        nvme.cluster_device_order = dev_order
+        dev_order += 1
+        if nvme.size < jm_device.size:
+            jm_device = nvme
+        device_events.device_create(nvme)
+    jm_device.status = NVMeDevice.STATUS_JM
+
+    rpc_client = RPCClient(snode.mgmt_ip, snode.rpc_port, snode.rpc_username, snode.rpc_password)
+
+    new_devices = []
+    for index, nvme in enumerate(devices):
+        if nvme.status not in [NVMeDevice.STATUS_ONLINE, NVMeDevice.STATUS_UNAVAILABLE,
+                               NVMeDevice.STATUS_JM, NVMeDevice.STATUS_READONLY]:
+            logger.debug(f"Device is not online or unavailable: {nvme.get_id()}, status: {nvme.status}")
+            continue
+
+        if nvme.status == NVMeDevice.STATUS_JM:
+            jm_device = _create_jm_stack_on_device(rpc_client, nvme, snode, after_restart=False)
+            if not jm_device:
+                logger.error(f"Failed to create JM device")
+                return False
+            snode.jm_device = jm_device
+        else:
+            new_device = _create_storage_device_stack(rpc_client, nvme, snode, after_restart=False)
+            if not new_device:
+                logger.error("failed to create dev stack")
+                return False
+            new_device.cluster_device_order = dev_order
+            dev_order += 1
+            new_devices.append(new_device)
+            device_events.device_create(new_device)
+
+    snode.nvme_devices = new_devices
+    return True
+
+
 def _prepare_cluster_devices_on_restart(snode):
 
     rpc_client = RPCClient(
@@ -423,11 +491,6 @@ def _prepare_cluster_devices_on_restart(snode):
             logger.debug(f"Device is skipped: {nvme.get_id()}, status: {nvme.status}")
             continue
 
-        ret = rpc_client.get_bdevs(nvme.nvme_bdev)
-        if not ret:
-            logger.error(f"Device partition not found {nvme.nvme_bdev}")
-            nvme_dict = ret[0]
-
         dev = _create_storage_device_stack(rpc_client, nvme, snode, after_restart=True)
         if not dev:
             logger.error(f"Failed to create dev stack {nvme.get_id()}")
@@ -436,17 +499,12 @@ def _prepare_cluster_devices_on_restart(snode):
 
     # prepare JM device
     jm_device = snode.jm_device
-    ret = rpc_client.bdev_raid_create(jm_device.raid_bdev, jm_device.jm_nvme_bdev_list)
-    if not ret:
-        logger.error(f"Failed to create raid_jm_{snode.get_id()}")
-        return False
-    ret = rpc_client.bdev_alceml_create(jm_device.alceml_bdev, jm_device.raid_bdev, str(uuid.uuid4()), pba_init_mode=2)
-    if not ret:
-        logger.error(f"Failed to create alceml bdev: {jm_device.alceml_bdev}")
-        return False
-    ret = rpc_client.bdev_jm_create(jm_device.jm_bdev, jm_device.alceml_bdev)
+    if jm_device.jm_nvme_bdev_list:
+        ret = _create_jm_stack_on_raid(rpc_client, jm_device.jm_nvme_bdev_list, snode, after_restart=False)
+    else:
+        ret = _create_jm_stack_on_device(rpc_client, jm_device.nvme_device, snode, after_restart=True)
     if not ret:
-        logger.error(f"Failed to create {jm_device.jm_bdev}")
+        logger.error(f"Failed to create JM device")
         return False
 
     return True
@@ -732,7 +790,10 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
         return False
 
     # prepare devices
-    ret = _prepare_cluster_devices_2(snode, nvme_devs, after_restart=False)
+    if snode.num_partitions_per_dev == 0 or snode.jm_percent == 0:
+        ret = _prepare_cluster_devices_jm_on_dev(snode, nvme_devs)
+    else:
+        ret = _prepare_cluster_devices_partitions(snode, nvme_devs)
     if not ret:
         logger.error("Failed to prepare cluster devices")
         return False
@@ -799,140 +860,6 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     return "Success"
 
 
-# Deprecated
-def add_storage_node(cluster_id, iface_name, data_nics):
-    db_controller = DBController()
-    kv_store = db_controller.kv_store
-
-    cluster = db_controller.get_cluster_by_id(cluster_id)
-    if not cluster:
-        logger.error("Cluster not found: %s", cluster_id)
-        return False
-
-    logger.info("Add Storage node")
-
-    hostname = utils.get_hostname()
-    snode = db_controller.get_storage_node_by_hostname(hostname)
-    if snode:
-        logger.error("Node already exists, try remove it first.")
-        exit(1)
-    else:
-        snode = StorageNode()
-        snode.uuid = str(uuid.uuid4())
-
-    mgmt_ip = _get_if_ip_address(iface_name)
-    system_id = utils.get_system_id()
-
-    BASE_NQN = cluster.nqn.split(":")[0]
-    subsystem_nqn = f"{BASE_NQN}:{hostname}"
-
-    if data_nics:
-        data_nics = _get_data_nics(data_nics)
-    else:
-        data_nics = _get_data_nics([iface_name])
-
-    rpc_user, rpc_pass = utils.generate_rpc_user_and_pass()
-
-    # creating storage node object
-    snode.status = StorageNode.STATUS_IN_CREATION
-    snode.baseboard_sn = utils.get_baseboard_sn()
-    snode.system_uuid = system_id
-    snode.hostname = hostname
-    snode.host_nqn = subsystem_nqn
-    snode.subsystem = subsystem_nqn
-    snode.data_nics = data_nics
-    snode.mgmt_ip = mgmt_ip
-    snode.rpc_port = constants.RPC_HTTP_PROXY_PORT
-    snode.rpc_username = rpc_user
-    snode.rpc_password = rpc_pass
-    snode.cluster_id = cluster_id
-    snode.write_to_db(kv_store)
-
-    # creating RPCClient instance
-    rpc_client = RPCClient(
-        snode.mgmt_ip,
-        snode.rpc_port,
-        snode.rpc_username,
-        snode.rpc_password)
-
-    logger.info("Getting nvme devices")
-    devs = get_nvme_devices()
-    logger.debug(devs)
-    pcies = [d[0] for d in devs]
-    nvme_devs = addNvmeDevices(cluster, rpc_client, pcies, snode)
-    if not nvme_devs:
-        logger.error("No NVMe devices was found!")
-
-    logger.debug(nvme_devs)
-    snode.nvme_devices = nvme_devs
-
-    # Set device cluster order
-    dev_order = get_next_cluster_device_order(db_controller, cluster_id)
-    for index, nvme in enumerate(snode.nvme_devices):
-        nvme.cluster_device_order = dev_order
-        dev_order += 1
-    snode.write_to_db(db_controller.kv_store)
-
-    # prepare devices
-    # _prepare_cluster_devices(snode)
-
-    logger.info("Connecting to remote devices")
-    remote_devices = _connect_to_remote_devs(snode)
-    snode.remote_devices = remote_devices
-
-    logger.info("Setting node status to Active")
-    snode.status = StorageNode.STATUS_ONLINE
-    snode.write_to_db(kv_store)
-
-    # make other nodes connect to the new devices
-    logger.info("Make other nodes connect to the new devices")
-    snodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
-    for node_index, node in enumerate(snodes):
-        if node.get_id() == snode.get_id():
-            continue
-        logger.info(f"Connecting to node: {node.get_id()}")
-        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password)
-        count = 0
-        for dev in snode.nvme_devices:
-            name = f"remote_{dev.alceml_bdev}"
-            ret = rpc_client.bdev_nvme_attach_controller_tcp(name, dev.nvmf_nqn, dev.nvmf_ip, dev.nvmf_port)
-            if not ret:
-                logger.error(f"Failed to connect to device: {name}")
-                continue
-
-            dev.remote_bdev = f"{name}n1"
-            idx = -1
-            for i, d in enumerate(node.remote_devices):
-                if d.get_id() == dev.get_id():
-                    idx = i
-                    break
-            if idx >= 0:
-                node.remote_devices[idx] = dev
-            else:
-                node.remote_devices.append(dev)
-            count += 1
-        node.write_to_db(kv_store)
-        logger.info(f"connected to devices count: {count}")
-
-    logger.info("Sending cluster map")
-    ret = distr_controller.send_cluster_map_to_node(snode)
-    if not ret:
-        return False, "Failed to send cluster map"
-    ret = distr_controller.send_cluster_map_add_node(snode)
-    if not ret:
-        return False, "Failed to send cluster map add node"
-    time.sleep(3)
-
-    logger.info("Sending cluster event updates")
-    distr_controller.send_node_status_event(snode, StorageNode.STATUS_ONLINE)
-
-    for dev in snode.nvme_devices:
-        distr_controller.send_dev_status_event(dev, NVMeDevice.STATUS_ONLINE)
-
-    logger.info("Done")
-    return "Success"
-
-
 def delete_storage_node(node_id):
     db_controller = DBController()
     snode = db_controller.get_storage_node_by_id(node_id)
@@ -1038,7 +965,6 @@ def remove_storage_node(node_id, force_remove=False, force_migrate=False):
 
 def restart_storage_node(
         node_id,
-        spdk_cpu_mask=None,
         spdk_mem=None,
         spdk_image=None,
         set_spdk_debug=None,