sbcli-pre 1.2.5__zip → 1.2.7__zip

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_core/utils.py

@@ -257,7 +257,7 @@ def process_records(records, records_count):
 
 def ping_host(ip):
     logger.debug(f"Pinging ip ... {ip}")
-    response = os.system(f"ping -c 1 {ip} > /dev/null")
+    response = os.system(f"ping -c 1 -W 3 {ip} > /dev/null")
     if response == 0:
         logger.debug(f"{ip} is UP")
         return True
@@ -280,3 +280,128 @@ def sum_records(records):
 
 def get_random_vuid():
     return 1 + int(random.random() * 10000)
+
+
+def calculate_core_allocation(cpu_count):
+    '''
+    If number of cpu cores >= 8, tune cpu core mask
+        1. Never use core 0 for spdk.
+        2. For every 8 cores, leave one core to the operating system
+        3. Do not use more than 15% of remaining available cores for nvme pollers
+        4. Use one dedicated core for app_thread
+        5. distribute distrib bdevs and alceml bdevs to all other cores
+    JIRA ticket link/s
+    https://simplyblock.atlassian.net/browse/SFAM-885
+    '''
+
+    all_cores = list(range(0, cpu_count))
+    # Calculate the number of cores to exclude for the OS
+    if cpu_count == 8:
+        os_cores_count = 1
+    else:
+        os_cores_count = 1 + (cpu_count // 8)
+
+    # Calculate os cores
+    os_cores = all_cores[0:os_cores_count]
+
+    # Calculate available cores
+    available_cores_count = cpu_count - os_cores_count
+
+    # Calculate NVMe pollers
+    nvme_pollers_count = int(available_cores_count * 0.15)
+    nvme_pollers_cores = all_cores[os_cores_count:os_cores_count + nvme_pollers_count]
+
+    # Allocate core for app_thread
+    app_thread_core = all_cores[os_cores_count + nvme_pollers_count:os_cores_count + nvme_pollers_count + 1]
+
+    # Calculate bdb_lcpu cores
+    bdb_lcpu_cores = all_cores[os_cores_count + nvme_pollers_count + 1:]
+
+    return os_cores, nvme_pollers_cores, app_thread_core, bdb_lcpu_cores
+
+
+def generate_mask(cores):
+    mask = 0
+    for core in cores:
+        mask |= (1 << core)
+    return f'0x{mask:X}'
+
+def calculate_pool_count(alceml_count, lvol_count, snap_count, cpu_count, poller_count):
+    '''
+    				        Small pool count				            Large pool count
+    Create JM			    256						                    32					                    For each JM
+
+    Create Alceml 			256						                    32					                    For each Alceml
+
+    Create Distrib 			256						                    32					                    For each distrib
+
+    First Send cluster map	256						                    32					                    Calculated or one time
+
+    NVMF transport TCP 		127 * poll_groups_mask||CPUCount + 384		15 * poll_groups_mask||CPUCount + 384 	Calculated or one time
+
+    Subsystem add NS		128 * poll_groups_mask||CPUCount		    16 * poll_groups_mask||CPUCount		    Calculated or one time
+
+    Create snapshot			512						                    64					                    For each snapshot
+
+    Clone lvol			    256						                    32					                    For each clone
+    '''
+    poller_number = poller_count if poller_count else cpu_count
+    small_pool_count = (3 + alceml_count + lvol_count + 2 * snap_count + 1) * 256 + poller_number * 127 + 384 + 128 * poller_number + constants.EXTRA_SMALL_POOL_COUNT
+    large_pool_count = (3 + alceml_count + lvol_count + 2 * snap_count + 1) * 32 + poller_number * 15 + 384 + 16 * poller_number + constants.EXTRA_LARGE_POOL_COUNT
+    return small_pool_count, large_pool_count
+
+
+def calculate_minimum_hp_memory(small_pool_count, large_pool_count, lvol_count, snap_count, cpu_count):
+    '''
+    1092 (initial consumption) + 4 * CPU + 1.0277 * POOL_COUNT(Sum in MB) + (7 + 6) * lvol_count + 12 * snap_count
+    then you can amend the expected memory need for the creation of lvols (6MB),
+    connection number over lvols (7MB per connection), creation of snaps (12MB),
+    extra buffer 2GB
+    return: minimum_hp_memory in bytes
+    '''
+    pool_consumption = (small_pool_count * 8 + large_pool_count * 128) / 1024 + 1092
+    memory_consumption = (4 * cpu_count + 1.0277 * pool_consumption + (6 + 7) * lvol_count + 12 * snap_count) * (1024 * 1024) + constants.EXTRA_HUGE_PAGE_MEMORY
+    return memory_consumption
+
+
+def calculate_minimum_sys_memory(max_prov):
+    max_prov_tb = max_prov / (1024 * 1024 * 1024 * 1024)
+    minimum_sys_memory = (250 * 1024 * 1024) * 1.1 * max_prov_tb + constants.EXTRA_SYS_MEMORY
+    logger.debug(f"Minimum system memory is {humanbytes(minimum_sys_memory)}")
+    return minimum_sys_memory
+
+
+def calculate_spdk_memory(minimum_hp_memory, minimum_sys_memory, free_sys_memory, huge_total_memory):
+    total_free_memory = free_sys_memory + huge_total_memory
+    if total_free_memory < (minimum_hp_memory + minimum_sys_memory):
+        logger.warning(f"Total free memory:{humanbytes(total_free_memory)}, "
+                       f"Minimum huge pages memory: {humanbytes(minimum_hp_memory)}, "
+                       f"Minimum system memory: {humanbytes(minimum_sys_memory)}")
+        return False, 0
+    spdk_mem = minimum_hp_memory + (total_free_memory - minimum_hp_memory - minimum_sys_memory) * 0.2
+    logger.debug(f"SPDK memory is {humanbytes(spdk_mem)}")
+    return True, spdk_mem
+
+
+def get_total_size_per_instance_type(instance_type):
+    instance_storage_data = constants.INSTANCE_STORAGE_DATA
+    if instance_type in instance_storage_data:
+        number_of_devices = instance_storage_data[instance_type]["number_of_devices"]
+        device_size = instance_storage_data[instance_type]["size_per_device_gb"]
+        return True, number_of_devices, device_size
+
+    return False, 0, 0
+
+
+def validate_add_lvol_or_snap_on_node(memory_free, huge_free, max_lvol_or_snap,
+                                      lvol_or_snap_size, node_capacity, node_lvol_or_snap_count):
+    min_sys_memory = 2 / 4096 * lvol_or_snap_size +  1 / 4096 * node_capacity + constants.MIN_SYS_MEMORY_FOR_LVOL
+    if huge_free < constants.MIN_HUGE_PAGE_MEMORY_FOR_LVOL:
+        return f"No enough huge pages memory on the node, Free memory: {humanbytes(huge_free)}, " \
+               f"Min Huge memory required: {humanbytes(constants.MIN_HUGE_PAGE_MEMORY_FOR_LVOL)}"
+    if memory_free < min_sys_memory:
+        return f"No enough system memory on the node, Free Memory: {humanbytes(memory_free)}, " \
+               f"Min Sys memory required: {humanbytes(min_sys_memory)}"
+    if node_lvol_or_snap_count >= max_lvol_or_snap:
+        return f"You have exceeded the max number of lvol/snap {max_lvol_or_snap}"
+    return ""

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/blueprints/snode_ops.py

@@ -14,7 +14,8 @@ from flask import request
 
 from simplyblock_web import utils, node_utils
 
-from simplyblock_core import scripts, constants
+from simplyblock_core import scripts, constants, shell_utils
+from ec2_metadata import ec2_metadata
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -22,11 +23,24 @@ bp = Blueprint("snode", __name__, url_prefix="/snode")
 
 cluster_id_file = "/etc/foundationdb/sbcli_cluster_id"
 
-cpu_info = cpuinfo.get_cpu_info()
-hostname, _, _ = node_utils.run_command("hostname -s")
-system_id = ""
+CPU_INFO = cpuinfo.get_cpu_info()
+HOSTNAME, _, _ = node_utils.run_command("hostname -s")
+SYSTEM_ID = ""
+EC2_PUBLIC_IP = ""
+EC2_MD = ""
+
 try:
-    system_id, _, _ = node_utils.run_command("dmidecode -s system-uuid")
+    SYSTEM_ID = ec2_metadata.instance_id
+except:
+    SYSTEM_ID, _, _ = node_utils.run_command("dmidecode -s system-uuid")
+
+try:
+    EC2_PUBLIC_IP = ec2_metadata.public_ipv4
+except:
+    pass
+
+try:
+    EC2_MD = ec2_metadata.instance_identity_document
 except:
     pass
 
@@ -67,23 +81,10 @@ def spdk_process_start():
     spdk_cpu_mask = None
     if 'spdk_cpu_mask' in data:
         spdk_cpu_mask = data['spdk_cpu_mask']
+
     spdk_mem = None
     if 'spdk_mem' in data:
         spdk_mem = data['spdk_mem']
-    node_cpu_count = os.cpu_count()
-
-    if spdk_cpu_mask:
-        try:
-            requested_cpu_count = len(format(int(spdk_cpu_mask, 16), 'b'))
-            if requested_cpu_count > node_cpu_count:
-                return utils.get_response(
-                    False,
-                    f"The requested cpu count: {requested_cpu_count} "
-                    f"is larger than the node's cpu count: {node_cpu_count}")
-        except:
-            spdk_cpu_mask = hex(int(math.pow(2, node_cpu_count)) - 1)
-    else:
-        spdk_cpu_mask = hex(int(math.pow(2, node_cpu_count)) - 1)
 
     if spdk_mem:
         spdk_mem = int(utils.parse_size(spdk_mem) / (1000 * 1000))
@@ -229,11 +230,11 @@ def get_info():
     out = {
         "cluster_id": get_cluster_id(),
 
-        "hostname": hostname,
-        "system_id": system_id,
+        "hostname": HOSTNAME,
+        "system_id": SYSTEM_ID,
 
-        "cpu_count": cpu_info['count'],
-        "cpu_hz": cpu_info['hz_advertised'][0],
+        "cpu_count": CPU_INFO['count'],
+        "cpu_hz": CPU_INFO['hz_advertised'][0],
 
         "memory": node_utils.get_memory(),
         "hugepages": node_utils.get_huge_memory(),
@@ -247,9 +248,9 @@ def get_info():
 
         "network_interface": node_utils.get_nics_data(),
 
-        "ec2_metadata": get_ec2_meta(),
+        "ec2_metadata": EC2_MD,
 
-        "ec2_public_ip": get_ec2_public_ip(),
+        "ec2_public_ip": EC2_PUBLIC_IP,
     }
     return utils.get_response(out)
 
@@ -303,3 +304,80 @@ def leave_swarm():
     except:
         pass
     return utils.get_response(True)
+
+
+@bp.route('/make_gpt_partitions', methods=['POST'])
+def make_gpt_partitions_for_nbd():
+    nbd_device = '/dev/nbd0'
+    jm_percent = '3'
+    num_partitions = 1
+
+    try:
+        data = request.get_json()
+        nbd_device = data['nbd_device']
+        jm_percent = data['jm_percent']
+        num_partitions = data['num_partitions']
+    except:
+        pass
+
+    cmd_list = [
+        f"parted -fs {nbd_device} mklabel gpt",
+        f"parted -f {nbd_device} mkpart journal \"0%\" \"{jm_percent}%\""
+    ]
+    sg_cmd_list = [
+        f"sgdisk -t 1:6527994e-2c5a-4eec-9613-8f5944074e8b {nbd_device}",
+    ]
+    perc_per_partition = int((100 - jm_percent) / num_partitions)
+    for i in range(num_partitions):
+        st = jm_percent + (i * perc_per_partition)
+        en = st + perc_per_partition
+        cmd_list.append(f"parted -f {nbd_device} mkpart part{(i+1)} \"{st}%\" \"{en}%\"")
+        sg_cmd_list.append(f"sgdisk -t {(i+2)}:6527994e-2c5a-4eec-9613-8f5944074e8b {nbd_device}")
+
+    for cmd in cmd_list+sg_cmd_list:
+        logger.debug(cmd)
+        out, err, ret_code = shell_utils.run_command(cmd)
+        logger.debug(out)
+        logger.debug(ret_code)
+        if ret_code != 0:
+            logger.error(err)
+            return utils.get_response(False, f"Error running cmd: {cmd}, returncode: {ret_code}, output: {out}, err: {err}")
+        time.sleep(1)
+
+    return utils.get_response(True)
+
+
+@bp.route('/delete_dev_gpt_partitions', methods=['POST'])
+def delete_gpt_partitions_for_dev():
+
+    data = request.get_json()
+
+    if "device_pci" not in data:
+        return utils.get_response(False, "Required parameter is missing: device_pci")
+
+    device_pci = data['device_pci']
+
+    cmd_list = [
+        f"echo -n \"{device_pci}\" > /sys/bus/pci/drivers/uio_pci_generic/unbind",
+        f"echo -n \"{device_pci}\" > /sys/bus/pci/drivers/nvme/bind",
+    ]
+
+    for cmd in cmd_list:
+        logger.debug(cmd)
+        ret = os.popen(cmd).read().strip()
+        logger.debug(ret)
+        time.sleep(1)
+
+    device_name = os.popen(f"ls /sys/devices/pci0000:00/{device_pci}/nvme/nvme*/ | grep nvme").read().strip()
+    cmd_list = [
+        f"parted -fs /dev/{device_name} mklabel gpt",
+        f"echo -n \"{device_pci}\" > /sys/bus/pci/drivers/nvme/unbind",
+    ]
+
+    for cmd in cmd_list:
+        logger.debug(cmd)
+        ret = os.popen(cmd).read().strip()
+        logger.debug(ret)
+        time.sleep(1)
+
+    return utils.get_response(True)

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/blueprints/web_api_cluster.py

@@ -22,50 +22,27 @@ db_controller = kv_store.DBController()
 
 @bp.route('/cluster', methods=['POST'])
 def add_cluster():
+
+    blk_size = 512
+    page_size_in_blocks = 2097152
+    cap_warn = 0
+    cap_crit = 0
+    prov_cap_warn = 0
+    prov_cap_crit = 0
+
     cl_data = request.get_json()
-    if 'blk_size' not in cl_data:
-        return utils.get_response_error("missing required param: blk_size", 400)
-    if 'page_size_in_blocks' not in cl_data:
-        return utils.get_response_error("missing required param: page_size_in_blocks", 400)
-    if 'model_ids' not in cl_data:
-        return utils.get_response_error("missing required param: model_ids", 400)
-    if 'ha_type' not in cl_data:
-        return utils.get_response_error("missing required param: ha_type", 400)
-    if 'tls' not in cl_data:
-        return utils.get_response_error("missing required param: tls", 400)
-    if 'auth-hosts-only' not in cl_data:
-        return utils.get_response_error("missing required param: auth-hosts-only", 400)
-    if 'dhchap' not in cl_data:
-        return utils.get_response_error("missing required param: dhchap", 400)
-    if 'NQN' not in cl_data:
-        return utils.get_response_error("missing required param: NQN", 400)
-
-    c = Cluster()
-    c.uuid = str(uuid.uuid4())
-
-    if cl_data['blk_size'] not in [512, 4096]:
-        return utils.get_response_error("blk_size can be 512 or 4096", 400)
-
-    if cl_data['ha_type'] not in ["single", "ha"]:
-        return utils.get_response_error("ha_type can be single or ha", 400)
-
-    if cl_data['dhchap'] not in ["off", "one-way", "bi-direct"]:
-        return utils.get_response_error("dhchap can be off, one-way or bi-direct", 400)
-
-    c.blk_size = cl_data['blk_size']
-    c.page_size_in_blocks = cl_data['page_size_in_blocks']
-    c.model_ids = cl_data['model_ids']
-    c.ha_type = cl_data['ha_type']
-    c.tls = cl_data['tls']
-    c.auth_hosts_only = cl_data['auth-hosts-only']
-    c.nqn = cl_data['nqn']
-    c.iscsi = cl_data['iscsi'] or False
-    c.dhchap = cl_data['dhchap']
-    c.cluster_status = Cluster.STATUS_ACTIVE
-    c.updated_at = int(time.time())
-    c.write_to_db(db_controller.kv_store)
-
-    return utils.get_response(c.to_dict()), 201
+    if 'blk_size' in cl_data:
+        if cl_data['blk_size'] not in [512, 4096]:
+            return utils.get_response_error("blk_size can be 512 or 4096", 400)
+        else:
+            blk_size = cl_data['blk_size']
+
+    if 'page_size_in_blocks' in cl_data:
+        page_size_in_blocks = cl_data['page_size_in_blocks']
+
+    ret = cluster_ops.add_cluster(blk_size, page_size_in_blocks, cap_warn, cap_crit, prov_cap_warn, prov_cap_crit)
+
+    return utils.get_response(ret)
 
 
 @bp.route('/cluster', methods=['GET'], defaults={'uuid': None})

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/blueprints/web_api_device.py

@@ -3,7 +3,7 @@
 
 import logging
 
-from flask import Blueprint
+from flask import Blueprint, request
 
 from simplyblock_core.controllers import device_controller
 from simplyblock_web import utils
@@ -33,12 +33,15 @@ def list_devices_by_node(uuid):
 def list_storage_devices(uuid):
     devices = []
     if uuid:
-        dev = db_controller.get_storage_devices(uuid)
+        dev = db_controller.get_storage_device_by_id(uuid)
         if not dev:
             return utils.get_response_error(f"device not found: {uuid}", 404)
         devices = [dev]
     else:
-        devices = db_controller.get_storage_devices()
+        cluster_id = utils.get_cluster_id(request)
+        nodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
+        for node in nodes:
+            devices.append(node.nvme_devices)
     data = []
     for dev in devices:
         data.append(dev.get_clean_dict())
@@ -47,7 +50,7 @@ def list_storage_devices(uuid):
 @bp.route('/device/capacity/<string:uuid>/history/<string:history>', methods=['GET'])
 @bp.route('/device/capacity/<string:uuid>', methods=['GET'], defaults={'history': None})
 def device_capacity(uuid, history):
-    device = db_controller.get_storage_devices(uuid)
+    device = db_controller.get_storage_device_by_id(uuid)
     if not device:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 
@@ -58,7 +61,7 @@ def device_capacity(uuid, history):
 @bp.route('/device/iostats/<string:uuid>/history/<string:history>', methods=['GET'])
 @bp.route('/device/iostats/<string:uuid>', methods=['GET'], defaults={'history': None})
 def device_iostats(uuid, history):
-    devices = db_controller.get_storage_devices(uuid)
+    devices = db_controller.get_storage_device_by_id(uuid)
     if not devices:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 
@@ -71,7 +74,7 @@ def device_iostats(uuid, history):
 
 @bp.route('/device/reset/<string:uuid>', methods=['GET'])
 def device_reset(uuid):
-    devices = db_controller.get_storage_devices(uuid)
+    devices = db_controller.get_storage_device_by_id(uuid)
     if not devices:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 
@@ -81,7 +84,7 @@ def device_reset(uuid):
 
 @bp.route('/device/remove/<string:uuid>', methods=['GET'])
 def device_remove(uuid):
-    devices = db_controller.get_storage_devices(uuid)
+    devices = db_controller.get_storage_device_by_id(uuid)
     if not devices:
         return utils.get_response_error(f"devices not found: {uuid}", 404)
 

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/blueprints/web_api_lvol.py

@@ -19,17 +19,21 @@ bp = Blueprint("lvol", __name__)
 db_controller = kv_store.DBController()
 
 
-@bp.route('/lvol', defaults={'uuid': None}, methods=['GET'])
-@bp.route('/lvol/<string:uuid>', methods=['GET'])
-def list_lvols(uuid):
+@bp.route('/lvol', defaults={'uuid': None, "cluster_id": None}, methods=['GET'])
+@bp.route('/lvol/<string:uuid>', defaults={"cluster_id": None}, methods=['GET'])
+@bp.route('/lvol/cluster_id/<string:cluster_id>', defaults={'uuid': None,}, methods=['GET'])
+def list_lvols(uuid, cluster_id):
     if uuid:
         lvol = db_controller.get_lvol_by_id(uuid)
         if lvol:
             lvols = [lvol]
         else:
             return utils.get_response_error(f"LVol not found: {uuid}", 404)
+    elif cluster_id:
+        lvols = db_controller.get_lvols(cluster_id)
     else:
-        lvols = db_controller.get_lvols()
+        cluster_id = utils.get_cluster_id(request)
+        lvols = db_controller.get_lvols(cluster_id)
     data = []
     for lvol in lvols:
         data.append(lvol.get_clean_dict())
@@ -123,7 +127,7 @@ def add_lvol():
     if not pool:
         return utils.get_response(None, f"Pool not found: {pool_id_or_name}", 400)
 
-    for lvol in db_controller.get_lvols():
+    for lvol in db_controller.get_lvols():  # pass
         if lvol.pool_uuid == pool.get_id():
             if lvol.lvol_name == name:
                 return utils.get_response(lvol.get_id())

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/blueprints/web_api_pool.py

@@ -17,17 +17,21 @@ bp = Blueprint("pool", __name__)
 db_controller = kv_store.DBController()
 
 
-@bp.route('/pool', defaults={'uuid': None}, methods=['GET'])
-@bp.route('/pool/<string:uuid>', methods=['GET'])
-def list_pools(uuid):
+@bp.route('/pool', defaults={'uuid': None, "cluster_id": None}, methods=['GET'])
+@bp.route('/pool/<string:uuid>', defaults={"cluster_id": None}, methods=['GET'])
+@bp.route('/pool/cluster_id/<string:cluster_id>', defaults={'uuid': None,}, methods=['GET'])
+def list_pools(uuid, cluster_id):
     if uuid:
         pool = db_controller.get_pool_by_id(uuid)
         if pool:
             pools = [pool]
         else:
             return utils.get_response_error(f"Pool not found: {uuid}", 404)
+    elif cluster_id:
+        pools = db_controller.get_pools(cluster_id)
     else:
-        pools = db_controller.get_pools()
+        cluster_id = utils.get_cluster_id(request)
+        pools = db_controller.get_pools(cluster_id)
     data = []
     for pool in pools:
         data.append(pool.get_clean_dict())
@@ -39,6 +43,7 @@ def add_pool():
     """
         Params:
         | name (required) | LVol name or id
+        | cluster_id (required) | Cluster uuid
         | pool_max        | Pool maximum size: 10M, 10G, 10(bytes)
         | lvol_max        | LVol maximum size: 10M, 10G, 10(bytes)
         | no_secret       | pool is created with a secret
@@ -51,7 +56,11 @@ def add_pool():
     if 'name' not in pool_data:
         return utils.get_response_error("missing required param: name", 400)
 
+    if 'cluster_id' not in pool_data:
+        return utils.get_response_error("missing required param: cluster_id", 400)
+
     name = pool_data['name']
+    cluster_id = pool_data['cluster_id']
     for p in db_controller.get_pools():
         if p.pool_name == name:
             return utils.get_response_error(f"Pool found with the same name: {name}", 400)
@@ -75,7 +84,7 @@ def add_pool():
 
     ret = pool_controller.add_pool(
         name, pool_max_size, lvol_max_size, max_rw_iops, max_rw_mbytes,
-        max_r_mbytes_per_sec, max_w_mbytes_per_sec, pool_secret)
+        max_r_mbytes_per_sec, max_w_mbytes_per_sec, pool_secret, cluster_id)
 
     return utils.get_response(ret)
 

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/blueprints/web_api_storage_node.py

@@ -30,7 +30,8 @@ def list_storage_nodes(uuid):
         else:
             return utils.get_response_error(f"node not found: {uuid}", 404)
     else:
-        nodes = db_controller.get_storage_nodes()
+        cluster_id = utils.get_cluster_id(request)
+        nodes = db_controller.get_storage_nodes_by_cluster_id(cluster_id)
     data = []
     for node in nodes:
         d = node.get_clean_dict()
@@ -162,9 +163,21 @@ def storage_node_add():
     if 'ifname' not in req_data:
         return utils.get_response_error("missing required param: ifname", 400)
 
+    if 'max_lvol' not in req_data:
+        return utils.get_response_error("missing required param: max_lvol", 400)
+
+    if 'max_snap' not in req_data:
+        return utils.get_response_error("missing required param: max_snap", 400)
+
+    if 'max_prov' not in req_data:
+        return utils.get_response_error("missing required param: max_prov", 400)
+
     cluster_id = req_data['cluster_id']
     node_ip = req_data['node_ip']
     ifname = req_data['ifname']
+    max_lvol = req_data['max_lvol']
+    max_snap = req_data['max_snap']
+    max_prov = req_data['max_prov']
 
     spdk_image = None
     if 'spdk_image' in req_data:
@@ -179,23 +192,10 @@ def storage_node_add():
         data_nics = req_data['data_nics']
         data_nics = data_nics.split(",")
 
-    spdk_cpu_mask = None
-    if 'spdk_cpu_mask' in req_data:
-        msk = req_data['spdk_cpu_mask']
-        if utils.validate_cpu_mask(msk):
-            spdk_cpu_mask = msk
-        else:
-            return utils.get_response_error(f"Invalid cpu mask value: {msk}", 400)
 
-    spdk_mem = None
-    if 'spdk_mem' in req_data:
-        mem = req_data['spdk_mem']
-        spdk_mem = utils.parse_size(mem)
-        if spdk_mem < 1 * 1024 * 1024:
-            return utils.get_response_error(f"SPDK memory:{mem} must be larger than 1G", 400)
 
     out = storage_node_ops.add_node(
-        cluster_id, node_ip, ifname, data_nics, spdk_cpu_mask, spdk_mem,
+        cluster_id, node_ip, ifname, data_nics, max_lvol, max_snap, max_prov,
         spdk_image=spdk_image, spdk_debug=spdk_debug)
 
     return utils.get_response(out)

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/node_utils.py

@@ -87,8 +87,6 @@ def get_nics_data():
         logger.error(err)
         return []
     data = json.loads(out)
-    logger.debug("ifaces")
-    logger.debug(data)
 
     def _get_ip4_address(list_of_addr):
         if list_of_addr:

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_web/utils.py

@@ -85,3 +85,11 @@ def get_int_value_or_default(data, key, default):
         return int(get_value_or_default(data, key, default))
     except Exception:
         return default
+
+
+def get_cluster_id(request):
+    au = request.headers["Authorization"]
+    if len(au.split()) == 2:
+        cluster_id = au.split()[0]
+        cluster_secret = au.split()[1]
+        return cluster_id

sbcli_pre-1.2.5/simplyblock_core/constants.py

@@ -1,65 +0,0 @@
-import logging
-import os
-
-KVD_DB_VERSION = 730
-KVD_DB_FILE_PATH = '/etc/foundationdb/fdb.cluster'
-KVD_DB_TIMEOUT_MS = 10000
-SPK_DIR = '/home/ec2-user/spdk'
-RPC_HTTP_PROXY_PORT = 8080
-LOG_LEVEL = logging.INFO
-LOG_WEB_DEBUG = True
-
-FILE_DIR = os.path.dirname(os.path.realpath(__file__))
-INSTALL_DIR = os.path.dirname(FILE_DIR)
-TOP_DIR = os.path.dirname(INSTALL_DIR)
-
-NODE_MONITOR_INTERVAL_SEC = 3
-DEVICE_MONITOR_INTERVAL_SEC = 5
-STAT_COLLECTOR_INTERVAL_SEC = 60*5  # 5 minutes
-LVOL_STAT_COLLECTOR_INTERVAL_SEC = 2
-LVOL_MONITOR_INTERVAL_SEC = 60
-DEV_MONITOR_INTERVAL_SEC = 10
-DEV_STAT_COLLECTOR_INTERVAL_SEC = 2
-PROT_STAT_COLLECTOR_INTERVAL_SEC = 2
-DISTR_EVENT_COLLECTOR_INTERVAL_SEC = 2
-DISTR_EVENT_COLLECTOR_NUM_OF_EVENTS = 20
-CAP_MONITOR_INTERVAL_SEC = 30
-SSD_VENDOR_WHITE_LIST = ["1d0f:cd01", "1d0f:cd00"]
-
-PMEM_DIR = '/tmp/pmem'
-
-NVME_PROGRAM_FAIL_COUNT = 50
-NVME_ERASE_FAIL_COUNT = 50
-NVME_CRC_ERROR_COUNT = 50
-DEVICE_OVERLOAD_STDEV_VALUE = 50
-DEVICE_OVERLOAD_CAPACITY_THRESHOLD = 50
-
-CLUSTER_NQN = "nqn.2023-02.io.simplyblock"
-
-weights = {
-    "lvol": 50,
-    "cpu": 10,
-    "r_io": 10,
-    "w_io": 10,
-    "r_b": 10,
-    "w_b": 10
-}
-
-# To use 75% of hugepages to calculate ssd size to use for the ocf bdev
-CACHING_NODE_MEMORY_FACTOR = 0.75
-
-HEALTH_CHECK_INTERVAL_SEC = 60
-
-GRAYLOG_CHECK_INTERVAL_SEC = 60
-
-FDB_CHECK_INTERVAL_SEC = 60
-
-SIMPLY_BLOCK_CLI_NAME = "sbcli-dev"
-TASK_EXEC_INTERVAL_SEC = 30
-TASK_EXEC_RETRY_COUNT = 8
-
-SIMPLY_BLOCK_DOCKER_IMAGE = "simplyblock/simplyblock:dev"
-SIMPLY_BLOCK_SPDK_CORE_IMAGE = "simplyblock/spdk-core:latest"
-SIMPLY_BLOCK_SPDK_ULTRA_IMAGE = "simplyblock/spdk:main-latest"
-
-GELF_PORT = 12201