sbcli-pre 1.2.3__zip → 1.2.5__zip

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/controllers/snapshot_controller.py

@@ -49,7 +49,7 @@ def add(lvol_id, snapshot_name):
     ret = rpc_client.bdev_distrib_create(
         base_name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
         lvol.distr_bs, lvol_controller.get_jm_names(snode), lvol.distr_chunk_bs,
-        None, None, lvol.distr_page_size, dev_cpu_mask=snode.dev_cpu_mask)
+        None, None, lvol.distr_page_size)
     if not ret:
         logger.error("Failed to create Distr bdev")
         return False, "Failed to create Distr bdev"
@@ -119,12 +119,7 @@ def delete(snapshot_uuid):
         logger.error(f"Snapshot not found {snapshot_uuid}")
         return False
 
-    snode = db_controller.get_storage_node_by_id(snap.lvol.node_id)
-    if not snode:
-        logger.error(f"Storage node not found {snap.lvol.node_id}")
-        return False
-
-    for lvol in db_controller.get_lvols(snode.cluster_id):
+    for lvol in db_controller.get_lvols():
         if lvol.cloned_from_snap and lvol.cloned_from_snap == snapshot_uuid:
             logger.warning(f"Soft delete snapshot with clones, lvol ID: {lvol.get_id()}")
             snap.deleted = True
@@ -232,8 +227,7 @@ def clone(snapshot_id, clone_name, new_size=0):
     name = f"distr_{new_vuid}_1"
     ret = rpc_client.bdev_distrib_create(
         name, new_vuid, lvol.ndcs, lvol.npcs, num_blocks,
-        lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size,
-        dev_cpu_mask=snode.dev_cpu_mask)
+        lvol.distr_bs, jm_names, lvol.distr_chunk_bs, None, None, lvol.distr_page_size)
     if not ret:
         msg="Failed to create Distr bdev"
         logger.error(msg)

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/distr_controller.py

@@ -10,9 +10,8 @@ from simplyblock_core.kv_store import DBController
 logger = logging.getLogger()
 
 
-def send_node_status_event(node, node_status):
+def send_node_status_event(node_id, node_status):
     db_controller = DBController()
-    node_id = node.get_id()
     logging.info(f"Sending event updates, node: {node_id}, status: {node_status}")
     node_status_event = {
         "timestamp": datetime.datetime.now().isoformat("T", "seconds") + 'Z',
@@ -21,7 +20,7 @@ def send_node_status_event(node, node_status):
         "status": node_status}
     events = {"events": [node_status_event]}
     logger.debug(node_status_event)
-    snodes = db_controller.get_storage_nodes_by_cluster_id(node.cluster_id)
+    snodes = db_controller.get_storage_nodes()
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -30,9 +29,8 @@ def send_node_status_event(node, node_status):
         ret = rpc_client.distr_status_events_update(events)
 
 
-def send_dev_status_event(device, dev_status):
+def send_dev_status_event(storage_ID, dev_status):
     db_controller = DBController()
-    storage_ID = device.cluster_device_order
     logging.info(f"Sending event updates, device: {storage_ID}, status: {dev_status}")
     node_status_event = {
         "timestamp": datetime.datetime.now().isoformat("T", "seconds") + 'Z',
@@ -41,7 +39,7 @@ def send_dev_status_event(device, dev_status):
         "status": dev_status}
     events = {"events": [node_status_event]}
     logger.debug(node_status_event)
-    snodes = db_controller.get_storage_nodes_by_cluster_id(device.cluster_id)
+    snodes = db_controller.get_storage_nodes()
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -54,7 +52,7 @@ def send_dev_status_event(device, dev_status):
 
 def disconnect_device(device):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes_by_cluster_id(device.cluster_id)
+    snodes = db_controller.get_storage_nodes()
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue
@@ -97,9 +95,7 @@ def get_distr_cluster_map(snodes, target_node):
             dev_map[dev.cluster_device_order] = {
                 "UUID": dev.get_id(),
                 "bdev_name": name,
-                "status": dev.status,
-                "physical_label": dev.physical_label
-            }
+                "status": dev.status}
             dev_w_map.append({
                 "weight": dev_w,
                 "id": dev.cluster_device_order})
@@ -162,7 +158,7 @@ def parse_distr_cluster_map(map_string):
                 "Actual Status": "",
                 "Results": "",
             }
-            sd = db_controller.get_storage_device_by_id(device_id)
+            sd = db_controller.get_storage_devices(device_id)
             if sd:
                 data["Actual Status"] = sd.status
                 if sd.status == status:
@@ -179,7 +175,7 @@ def parse_distr_cluster_map(map_string):
 
 def send_cluster_map_to_node(node):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes_by_cluster_id(node.cluster_id)
+    snodes = db_controller.get_storage_nodes()
     rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password)
     cluster_map_data = get_distr_cluster_map(snodes, node)
     cluster_map_data['UUID_node_target'] = node.get_id()
@@ -193,7 +189,7 @@ def send_cluster_map_to_node(node):
 
 def send_cluster_map_add_node(snode):
     db_controller = DBController()
-    snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
+    snodes = db_controller.get_storage_nodes()
     for node in snodes:
         if node.status != node.STATUS_ONLINE:
             continue

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/kv_store.py

@@ -9,6 +9,7 @@ from simplyblock_core.models.caching_node import CachingNode
 from simplyblock_core.models.cluster import ClusterMap
 
 from simplyblock_core.models.cluster import Cluster
+from simplyblock_core.models.deployer import Deployer
 from simplyblock_core.models.compute_node import ComputeNode
 from simplyblock_core.models.job_schedule import JobSchedule
 from simplyblock_core.models.port_stat import PortStat
@@ -97,19 +98,11 @@ class DBController:
                 nodes.append(n)
         return sorted(nodes, key=lambda x: x.create_dt)
 
-    def get_storage_node_by_system_id(self, system_id):
-        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_node_by_id(self, id):
         ret = StorageNode().read_from_db(self.kv_store, id)
         if ret:
             return ret[0]
 
-    # todo: change this function for multi cluster
     def get_caching_nodes(self):
         ret = CachingNode().read_from_db(self.kv_store)
         ret = sorted(ret, key=lambda x: x.create_dt)
@@ -120,12 +113,6 @@ class DBController:
         if ret:
             return ret[0]
 
-    def get_caching_node_by_system_id(self, system_id):
-        nodes = CachingNode().read_from_db(self.kv_store)
-        for node in nodes:
-            if node.system_uuid == system_id:
-                return node
-
     def get_caching_node_by_hostname(self, hostname):
         nodes = self.get_caching_nodes()
         for node in nodes:
@@ -138,15 +125,20 @@ class DBController:
             if node.hostname == hostname:
                 return node
 
-    def get_storage_device_by_id(self, id):
+    def get_storage_devices(self, id=""):
+        # workaround because nvme devices are stored inside the node object itself.
         nodes = self.get_storage_nodes()
+        devices = []
+        device = None
         for node in nodes:
-            for dev in node.nvme_devices:
-                if dev.get_id() == id:
-                    return dev
-
-    def get_storage_devices(self, id):
-        return self.get_storage_device_by_id(id)
+            if node.nvme_devices:
+                devices.extend(node.nvme_devices)
+                for dev in node.nvme_devices:
+                    if dev.get_id() == id:
+                        device = dev
+        if id:
+            return device
+        return devices
 
     # Compute node functions
     def get_compute_node_by_id(self, id):
@@ -158,15 +150,9 @@ class DBController:
         ret = ComputeNode().read_from_db(self.kv_store)
         return ret
 
-    def get_pools(self, cluster_id=None):
-        pools = []
-        if cluster_id:
-            for pool in Pool().read_from_db(self.kv_store):
-                if pool.cluster_id == cluster_id:
-                    pools.append(pool)
-        else:
-            pools = Pool().read_from_db(self.kv_store)
-        return pools
+    def get_pools(self):
+        ret = Pool().read_from_db(self.kv_store)
+        return ret
 
     def get_pool_by_id(self, id):
         ret = Pool().read_from_db(self.kv_store, id)
@@ -179,16 +165,9 @@ class DBController:
             if pool.pool_name == name:
                 return pool
 
-    def get_lvols(self, cluster_id=None):
-        lvols = []
-        if cluster_id:
-            for pool in self.get_pools(cluster_id):
-                if pool.cluster_id == cluster_id:
-                    for lv_id in pool.lvols:
-                        lvols.append(self.get_lvol_by_id(lv_id))
-        else:
-            lvols = LVol().read_from_db(self.kv_store)
-        return lvols
+    def get_lvols(self):
+        ret = LVol().read_from_db(self.kv_store)
+        return ret
 
     def get_snapshots(self):
         ret = SnapShot().read_from_db(self.kv_store)
@@ -265,6 +244,14 @@ class DBController:
         if ret:
             return ret[0]
 
+    def get_deployers(self):
+        return Deployer().read_from_db(self.kv_store)
+
+    def get_deployer_by_id(self, deployer_id):
+        ret = Deployer().read_from_db(self.kv_store, id=deployer_id)
+        if ret:
+            return ret[0]
+
     def get_port_stats(self, node_id, port_id, limit=20):
         stats = PortStat().read_from_db(self.kv_store, id="%s/%s" % (node_id, port_id), limit=limit, reverse=True)
         return stats
@@ -272,10 +259,5 @@ class DBController:
     def get_events(self, event_id=""):
         return EventObj().read_from_db(self.kv_store, id=event_id)
 
-    def get_job_tasks(self, cluster_id, reverse=True):
-        return JobSchedule().read_from_db(self.kv_store, id=cluster_id, reverse=reverse)
-
-    def get_task_by_id(self, task_id):
-        for task in self.get_job_tasks(""):
-            if task.uuid == task_id:
-                return task
+    def get_job_tasks(self, cluster_id):
+        return JobSchedule().read_from_db(self.kv_store, id=cluster_id, reverse=True)

sbcli_pre-1.2.5/simplyblock_core/mgmt_node_ops.py

@@ -0,0 +1,80 @@
+# coding=utf-8
+import json
+import logging
+import uuid
+
+import docker
+
+from simplyblock_core import utils
+from simplyblock_core.controllers import mgmt_events
+from simplyblock_core.kv_store import DBController
+from simplyblock_core.models.mgmt_node import MgmtNode
+
+logger = logging.getLogger()
+
+
+def add_mgmt_node(mgmt_ip, cluster_id=None):
+    db_controller = DBController()
+    hostname = utils.get_hostname()
+    node = db_controller.get_mgmt_node_by_hostname(hostname)
+    if node:
+        logger.error("Node already exists in the cluster")
+        return False
+
+    node = MgmtNode()
+    node.uuid = str(uuid.uuid4())
+    node.hostname = hostname
+    node.docker_ip_port = f"{mgmt_ip}:2375"
+    node.cluster_id = cluster_id
+    node.mgmt_ip = mgmt_ip
+    node.status = MgmtNode.STATUS_ONLINE
+    node.write_to_db(db_controller.kv_store)
+
+    mgmt_events.mgmt_add(node)
+    logger.info("Done")
+    return True
+
+
+def list_mgmt_nodes(is_json):
+    db_controller = DBController()
+    nodes = db_controller.get_mgmt_nodes()
+    data = []
+    output = ""
+
+    for node in nodes:
+        logging.debug(node)
+        logging.debug("*" * 20)
+        data.append({
+            "UUID": node.get_id(),
+            "Hostname": node.hostname,
+            "IP": node.mgmt_ip,
+            "Status": node.status,
+        })
+
+    if not data:
+        return output
+
+    if is_json:
+        output = json.dumps(data, indent=2)
+    else:
+        output = utils.print_table(data)
+    return output
+
+
+def remove_mgmt_node(uuid):
+    db_controller = DBController()
+    snode = db_controller.get_mgmt_node_by_id(uuid)
+    if not snode:
+        logger.error("can not find node")
+        return False
+
+    logging.info("Removing mgmt node")
+    snode.remove(db_controller.kv_store)
+
+    logger.info("Leaving swarm...")
+    node_docker = docker.DockerClient(base_url=f"tcp://{snode.docker_ip_port}", version="auto")
+    node_docker.swarm.leave()
+
+    mgmt_events.mgmt_remove(snode)
+    logging.info("done")
+

sbcli_pre-1.2.5/simplyblock_core/models/deployer.py

@@ -0,0 +1,62 @@
+# coding=utf-8
+from simplyblock_core.models.base_model import BaseModel
+
+class Deployer(BaseModel):
+
+    STATUS_ACTIVE = "active"
+    STATUS_READONLY = 'read_only'
+    STATUS_INACTIVE = "inactive"
+    STATUS_SUSPENDED = "suspended"
+    STATUS_DEGRADED = "degraded"
+
+    DOCKER_PULL = "dockerpull"
+    TF_STATE_INIT = "tfstate_init"
+    TF_PLAN = "tfplan"
+    TF_APPLY = "tfapply"
+
+    STATUS_CODE_MAP = {
+        DOCKER_PULL: 0,
+        TF_STATE_INIT: 1,
+        TF_PLAN: 2,
+        TF_APPLY: 3,
+    }
+
+    attributes = {
+        "uuid": {"type": str, 'default': ""},
+        "region": {"type": str, 'default': ""},
+        "availability_zone": {"type": str, 'default': ""},
+        "sbcli_cmd": {"type": str, 'default': ""},
+        "sbcli_pkg_version": {"type": str, 'default': ""},
+        "whitelist_ips": {"type": str, 'default': ""},  # todo: make this a list
+        "mgmt_nodes": {"type": int, 'default': 0},
+        "storage_nodes": {"type": int, 'default': 0},
+        "extra_nodes": {"type": int, 'default': 0},
+        "mgmt_nodes_instance_type": {"type": str, 'default': ""},
+        "storage_nodes_instance_type": {"type": str, 'default': ""},
+        "extra_nodes_instance_type": {"type": str, 'default': ""},
+        "storage_nodes_ebs_size1": {"type": int, 'default': 0},  # size in GB
+        "storage_nodes_ebs_size2": {"type": int, 'default': 0},  # size in GB
+        "volumes_per_storage_nodes": {"type": int, 'default': 0},
+        "nr_hugepages": {"type": int, 'default': 0},
+        "tf_state_bucket_name": {"type": str, 'default': ""},
+        "tf_state_bucket_region": {"type": str, 'default': ""},
+        "tf_workspace": {"type": str, 'default': ""},
+        "status": {"type": str, 'default': ""},
+        "tf_logs_bucket_name": {"type": str, 'default': ""},
+        "ecr_account_id": {"type": str, 'default': ""},
+        "ecr_region": {"type": str, 'default': ""},
+        "ecr_repository_name": {"type": str, 'default': ""},
+        "ecr_image_tag": {"type": str, 'default': ""},
+        "tf_output": {"type": str, 'default': ""},
+    }
+
+    def __init__(self, data=None):
+        super(Deployer, self).__init__()
+        self.set_attrs(self.attributes, data)
+        self.object_type = "object"
+
+    def get_id(self):
+        return self.uuid
+
+    def get_status_code(self):
+        return self.status

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/models/events.py

@@ -1,6 +1,4 @@
 # coding=utf-8
-from datetime import datetime
-
 from simplyblock_core.models.base_model import BaseModel
 
 
@@ -27,7 +25,7 @@ class EventObj(BaseModel):
         "uuid": {"type": str, 'default': ""},
         "cluster_uuid": {"type": str, 'default': ""},
         "node_id": {"type": str, 'default': ""},
-        "date": {"type": int, 'default': 0},  # in milliseconds
+        "date": {"type": int, 'default': 0},
 
         "event_level": {"type": str, 'default': LEVEL_INFO},
 
@@ -51,9 +49,3 @@ class EventObj(BaseModel):
 
     def get_id(self):
         return "%s/%s/%s" % (self.cluster_uuid, self.date, self.uuid)
-
-    def get_date_string(self):
-        if self.date > 1e10:
-            return str(datetime.fromtimestamp(self.date/1000))
-        else:
-            return str(datetime.fromtimestamp(self.date))

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/models/job_schedule.py

@@ -8,10 +8,6 @@ class JobSchedule(BaseModel):
     STATUS_RUNNING = 'running'
     STATUS_DONE = 'done'
 
-    FN_DEV_RESTART = "device_restart"
-    FN_NODE_RESTART = "node_restart"
-    FN_DEV_MIG = "device_migration"
-
     attributes = {
         "uuid": {"type": str, 'default': ""},
         "cluster_id": {"type": str, 'default': ""},
@@ -19,8 +15,6 @@ class JobSchedule(BaseModel):
         "device_id": {"type": str, 'default': ""},
         "date": {"type": int, 'default': 0},
 
-        "canceled": {"type": bool, 'default': False},
-
         "function_name": {"type": str, 'default': ""},
         "function_params": {"type": dict, 'default': {}},
         "function_result": {"type": str, 'default': ""},

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/models/nvme_device.py

@@ -28,7 +28,7 @@ class NVMeDevice(BaseModel):
         "serial_number": {"type": str, 'default': ""},
         "overload_percentage": {"type": int, 'default': 0},
         "nvme_bdev": {"type": str, 'default': ""},
-        "nvme_controller": {"type": str, 'default': ""},
+        "alloc_bdev": {"type": str, 'default': ""},
         "alceml_bdev": {"type": str, 'default': ""},
         "node_id": {"type": str, 'default': ""},
         "pt_bdev": {"type": str, 'default': ""},
@@ -37,6 +37,7 @@ class NVMeDevice(BaseModel):
         "nvmf_port": {"type": int, 'default': 0},
         "remote_bdev": {"type": str, 'default': ""},
         "testing_bdev": {"type": str, 'default': ""},
+        "jm_bdev": {"type": str, 'default': ""},
         "cluster_device_order": {"type": int, 'default': 0},
         "health_check": {"type": bool, "default": True},
         "cluster_id": {"type": str, 'default': ""},
@@ -46,13 +47,6 @@ class NVMeDevice(BaseModel):
         "io_error": {"type": bool, 'default': False},
         "retries_exhausted": {"type": bool, 'default': False},
 
-        "partition_main_bdev": {"type": str, 'default': ""},
-        "partition_main_size": {"type": int, 'default': 0},
-        "partition_jm_bdev": {"type": str, 'default': ""},
-        "partition_jm_size": {"type": int, 'default': 0},
-
-        "physical_label": {"type": int, 'default': 0},
-
     }
 
     def __init__(self, data=None):
@@ -63,37 +57,5 @@ class NVMeDevice(BaseModel):
     def get_id(self):
         return self.uuid
 
-
-class JMDevice(BaseModel):
-
-    STATUS_ONLINE = 'online'
-    STATUS_UNAVAILABLE = 'unavailable'
-    STATUS_REMOVED = 'removed'
-    STATUS_FAILED = 'failed'
-    STATUS_READONLY = 'read_only'
-
-    attributes = {
-        "uuid": {"type": str, 'default': ""},
-        "device_name": {"type": str, 'default': ""},
-        "status": {"type": str, 'default': ""},
-        "size": {"type": int, 'default': -1},
-
-        "jm_nvme_bdev_list": {"type": List[str], 'default': []},
-        "raid_bdev": {"type": str, 'default': ""},
-        "nvme_bdev": {"type": str, 'default': ""},
-        "alceml_bdev": {"type": str, 'default': ""},
-        "jm_bdev": {"type": str, 'default': ""},
-
-
-        "health_check": {"type": bool, "default": True},
-        "io_error": {"type": bool, 'default': False},
-    }
-
-    def __init__(self, data=None):
-        super(JMDevice, self).__init__()
-        self.set_attrs(self.attributes, data)
-        self.object_type = "object"
-
-    def get_id(self):
-        return self.uuid
-
+    def get_capacity_percentage(self):
+        return ((self.size - self.capacity) / self.size) * 100

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/models/storage_node.py

@@ -5,7 +5,7 @@ from typing import List
 
 from simplyblock_core.models.base_model import BaseModel
 from simplyblock_core.models.iface import IFace
-from simplyblock_core.models.nvme_device import NVMeDevice, JMDevice
+from simplyblock_core.models.nvme_device import NVMeDevice
 
 
 class StorageNode(BaseModel):
@@ -70,10 +70,6 @@ class StorageNode(BaseModel):
 
         # spdk params
         "spdk_cpu_mask": {"type": str, "default": ""},
-        "app_thread_mask": {"type": str, "default": ""},
-        "pollers_mask": {"type": str, "default": ""},
-        "os_cores": {"type": str, "default": []},
-        "dev_cpu_mask": {"type": str, "default": ""},
         "spdk_mem": {"type": int, "default": 0},
         "spdk_image": {"type": str, "default": ""},
         "spdk_debug": {"type": bool, "default": False},
@@ -88,10 +84,6 @@ class StorageNode(BaseModel):
         "iobuf_small_bufsize": {"type": int, "default": 0},
         "iobuf_large_bufsize": {"type": int, "default": 0},
 
-        "num_partitions_per_dev": {"type": int, "default": 1},
-        "jm_percent": {"type": int, "default": 3},
-        "jm_device": {"type": JMDevice, "default": None},
-
     }
 
     def __init__(self, data=None):

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_core/rpc_client.py

@@ -306,9 +306,9 @@ class RPCClient:
         params = {"name": name}
         return self._request("bdev_compress_delete", params)
 
-    def ultra21_bdev_pass_create(self, base_bdev, vuid, pt_name):
+    def ultra21_bdev_pass_create(self, alloc_bdev, vuid, pt_name):
         params = {
-            "base_bdev": base_bdev,
+            "base_bdev": alloc_bdev,
             "vuid": vuid,
             "pt_bdev": pt_name
         }
@@ -318,8 +318,7 @@ class RPCClient:
         params = {"name": name}
         return self._request2("ultra21_bdev_pass_delete", params)
 
-    def bdev_alceml_create(self, alceml_name, nvme_name, uuid, pba_init_mode=3,
-                           dev_cpu_mask=""):
+    def bdev_alceml_create(self, alceml_name, nvme_name, uuid, pba_init_mode=3):
         params = {
             "name": alceml_name,
             "cntr_path": nvme_name,
@@ -335,13 +334,10 @@ class RPCClient:
             "use_optimized": True,
             "pba_nbalign": 4096
         }
-        if dev_cpu_mask:
-            params["bdb_lcpu_mask"] = int(dev_cpu_mask,16)
         return self._request("bdev_alceml_create", params)
 
     def bdev_distrib_create(self, name, vuid, ndcs, npcs, num_blocks, block_size, jm_names,
-                            chunk_size, ha_comm_addrs=None, ha_inode_self=None, pba_page_size=2097152,
-                            dev_cpu_mask=""):
+                            chunk_size, ha_comm_addrs=None, ha_inode_self=None, pba_page_size=2097152):
         """"
             // Optional (not specified = no HA)
             // Comma-separated communication addresses, for each node, e.g. "192.168.10.1:45001,192.168.10.1:32768".
@@ -367,8 +363,6 @@ class RPCClient:
         if ha_comm_addrs:
             params['ha_comm_addrs'] = ha_comm_addrs
             params['ha_inode_self'] = ha_inode_self
-        if dev_cpu_mask:
-            params["bdb_lcpu_mask"] = int(dev_cpu_mask, 16)
 
         return self._request("bdev_distrib_create", params)
 
@@ -392,7 +386,7 @@ class RPCClient:
         params = {
             "name": name,
             "raid_level": "0",
-            "strip_size_kb": 4,
+            "strip_size_kb": 4 * len(bdevs_list),
             "base_bdevs": bdevs_list
         }
         return self._request("bdev_raid_create", params)
@@ -434,9 +428,8 @@ class RPCClient:
             "trsvcid": str(port),
             "subnqn": nqn,
             "fabrics_connect_timeout_us": 100000,
-            "fast_io_fail_timeout_sec": 1,
+            "fast_io_fail_timeout_sec": 0,
             "num_io_queues": 16384,
-            "ctrlr_loss_timeout_sec": 2,
         }
         return self._request("bdev_nvme_attach_controller", params)
 
@@ -484,9 +477,9 @@ class RPCClient:
         params = {
             "bdev_retry_count": 0,
             "transport_retry_count": 0,
-            "ctrlr_loss_timeout_sec": 2,
-            "fast_io_fail_timeout_sec": 1,
-            "reconnect_delay_sec": 1,
+            "ctrlr_loss_timeout_sec": -1,
+            "fast_io_fail_timeout_sec": 5,
+            "reconnect_delay_sec": 5,
             "keep_alive_timeout_ms": 200,
             "transport_ack_timeout": 7,
             "timeout_us": 100000
@@ -590,14 +583,12 @@ class RPCClient:
         }
         return self._request("ultra21_lvol_dismount", params)
 
-    def bdev_jm_create(self, name, name_storage1, block_size=4096, dev_cpu_mask=""):
+    def bdev_jm_create(self, name, name_storage1, block_size=4096):
         params = {
             "name": name,
             "name_storage1": name_storage1,
             "block_size": block_size
         }
-        if dev_cpu_mask:
-            params["bdb_lcpu_mask"] = int(dev_cpu_mask, 16)
         return self._request("bdev_jm_create", params)
 
     def bdev_jm_delete(self, name):
@@ -629,42 +620,6 @@ class RPCClient:
     def framework_start_init(self):
         return self._request("framework_start_init")
 
-    def bdev_examine(self, name):
-        params = {"name": name}
-        return self._request("bdev_examine", params)
-
-    def nbd_start_disk(self, bdev_name, nbd_device="/dev/nbd0"):
-        params = {
-            "bdev_name": bdev_name,
-            "nbd_device": nbd_device,
-        }
-        return self._request("nbd_start_disk", params)
-
-    def nbd_stop_disk(self, nbd_device):
-        params = {
-            "nbd_device": nbd_device
-        }
-        return self._request("nbd_stop_disk", params)
-
-
     def bdev_jm_unmap_vuid(self, name, vuid):
         params = {"name": name, "vuid": vuid}
         return self._request("bdev_jm_unmap_vuid", params)
-
-    def sock_impl_set_options(self):
-        method = "sock_impl_set_options"
-        params = {"impl_name": "posix", "enable_quickack": True,
-                  "enable_zerocopy_send_server": True,
-                  "enable_zerocopy_send_client": True}
-        return self._request(method, params)
-
-    def nvmf_set_config(self, poll_groups_mask):
-        params = {"poll_groups_mask": poll_groups_mask}
-        return self._request("nvmf_set_config", params)
-
-    def thread_get_stats(self):
-        return self._request("thread_get_stats")
-
-    def thread_set_cpumask(self, app_thread_process_id, app_thread_mask):
-        params = {"id": app_thread_process_id, "cpumask": app_thread_mask}
-        return self._request("thread_set_cpumask", params)