sbcli-pre 1.2.3__zip → 1.2.5__zip

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/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 -W 3 {ip} > /dev/null")
+    response = os.system(f"ping -c 1 {ip} > /dev/null")
     if response == 0:
         logger.debug(f"{ip} is UP")
         return True
@@ -280,48 +280,3 @@ 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}'

{sbcli_pre-1.2.3 → sbcli_pre-1.2.5}/simplyblock_web/app.py

@@ -7,7 +7,7 @@ from flask import Flask
 
 import utils
 from blueprints import web_api_cluster, web_api_mgmt_node, web_api_device, \
-    web_api_lvol, web_api_storage_node, web_api_pool, web_api_caching_node, web_api_snapshot
+    web_api_lvol, web_api_storage_node, web_api_pool, web_api_caching_node, web_api_snapshot, web_api_deployer
 from auth_middleware import token_required
 from simplyblock_core import constants
 
@@ -31,6 +31,7 @@ app.register_blueprint(web_api_snapshot.bp)
 app.register_blueprint(web_api_storage_node.bp)
 app.register_blueprint(web_api_pool.bp)
 app.register_blueprint(web_api_caching_node.bp)
+app.register_blueprint(web_api_deployer.bp)
 
 
 @app.before_request

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

@@ -14,8 +14,7 @@ from flask import request
 
 from simplyblock_web import utils, node_utils
 
-from simplyblock_core import scripts, constants, shell_utils
-from ec2_metadata import ec2_metadata
+from simplyblock_core import scripts, constants
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -23,24 +22,11 @@ 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 = ""
-EC2_PUBLIC_IP = ""
-EC2_MD = ""
-
+cpu_info = cpuinfo.get_cpu_info()
+hostname, _, _ = node_utils.run_command("hostname -s")
+system_id = ""
 try:
-    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
+    system_id, _, _ = node_utils.run_command("dmidecode -s system-uuid")
 except:
     pass
 
@@ -81,10 +67,23 @@ 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))
@@ -230,11 +229,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(),
@@ -248,9 +247,9 @@ def get_info():
 
         "network_interface": node_utils.get_nics_data(),
 
-        "ec2_metadata": EC2_MD,
+        "ec2_metadata": get_ec2_meta(),
 
-        "ec2_public_ip": EC2_PUBLIC_IP,
+        "ec2_public_ip": get_ec2_public_ip(),
     }
     return utils.get_response(out)
 
@@ -304,80 +303,3 @@ 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.3 → sbcli_pre-1.2.5}/simplyblock_web/blueprints/web_api_cluster.py

@@ -22,27 +22,50 @@ 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' 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)
+    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
 
 
 @bp.route('/cluster', methods=['GET'], defaults={'uuid': None})