sbcli-pre 1.4.4__zip → 1.4.6__zip

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/simplyblock_core/services/port_stat_collector.py

@@ -1,18 +1,14 @@
 # coding=utf-8
-import logging
-import os
-
 import time
-import sys
-
 import psutil
 
 
 from simplyblock_core import constants, kv_store, utils
 from simplyblock_core.models.port_stat import PortStat
 
-# Import the GELF logger
-from graypy import GELFUDPHandler
+
+logger = utils.get_logger(__name__)
+
 
 def update_port_stats(snode, nic, stats):
     now = int(time.time())
@@ -40,15 +36,6 @@ def update_port_stats(snode, nic, stats):
     return
 
 
-# configure logging
-logger_handler = logging.StreamHandler(stream=sys.stdout)
-logger_handler.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
-gelf_handler = GELFUDPHandler('0.0.0.0', constants.GELF_PORT)
-logger = logging.getLogger()
-logger.addHandler(gelf_handler)
-logger.addHandler(logger_handler)
-logger.setLevel(logging.DEBUG)
-
 # get DB controller
 db_controller = kv_store.DBController()
 

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/simplyblock_core/services/storage_node_monitor.py

@@ -1,29 +1,15 @@
 # coding=utf-8
-import logging
-import os
-
 import time
-import sys
-from datetime import datetime
 
 
-from simplyblock_core import constants, kv_store, cluster_ops, storage_node_ops, distr_controller
+from simplyblock_core import constants, kv_store, cluster_ops, storage_node_ops, utils
 from simplyblock_core.controllers import health_controller, device_controller, tasks_controller
 from simplyblock_core.models.cluster import Cluster
 from simplyblock_core.models.nvme_device import NVMeDevice
 from simplyblock_core.models.storage_node import StorageNode
 
-# Import the GELF logger
-from graypy import GELFUDPHandler
-
-# configure logging
-logger_handler = logging.StreamHandler(stream=sys.stdout)
-logger_handler.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
-gelf_handler = GELFUDPHandler('0.0.0.0', constants.GELF_PORT)
-logger = logging.getLogger()
-logger.addHandler(gelf_handler)
-logger.addHandler(logger_handler)
-logger.setLevel(logging.DEBUG)
+
+logger = utils.get_logger(__name__)
 
 
 # get DB controller

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/simplyblock_core/services/tasks_runner_migration.py

@@ -1,16 +1,13 @@
 # coding=utf-8
-import logging
 import time
-import sys
 
 
-from simplyblock_core import constants, kv_store
+from simplyblock_core import constants, kv_store, utils
 from simplyblock_core.controllers import tasks_events
 from simplyblock_core.models.job_schedule import JobSchedule
 
 
-# Import the GELF logger
-from graypy import GELFUDPHandler
+logger = utils.get_logger(__name__)
 
 
 def task_runner(task):
@@ -28,15 +25,6 @@ def task_runner(task):
     return True
 
 
-# configure logging
-logger_handler = logging.StreamHandler(stream=sys.stdout)
-logger_handler.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
-gelf_handler = GELFUDPHandler('0.0.0.0', constants.GELF_PORT)
-logger = logging.getLogger()
-logger.addHandler(gelf_handler)
-logger.addHandler(logger_handler)
-logger.setLevel(logging.DEBUG)
-
 # get DB controller
 db_controller = kv_store.DBController()
 

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/simplyblock_core/services/tasks_runner_restart.py

@@ -1,28 +1,15 @@
 # coding=utf-8
-import logging
 import time
-import sys
 
 
-from simplyblock_core import constants, kv_store, storage_node_ops
+from simplyblock_core import constants, kv_store, storage_node_ops, utils
 from simplyblock_core.controllers import device_controller, tasks_events, health_controller
 from simplyblock_core.models.job_schedule import JobSchedule
 from simplyblock_core.models.nvme_device import NVMeDevice
-
-# Import the GELF logger
-from graypy import GELFUDPHandler
-
 from simplyblock_core.models.storage_node import StorageNode
 
 
-# configure logging
-logger_handler = logging.StreamHandler(stream=sys.stdout)
-logger_handler.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
-gelf_handler = GELFUDPHandler('0.0.0.0', constants.GELF_PORT)
-logger = logging.getLogger()
-logger.addHandler(gelf_handler)
-logger.addHandler(logger_handler)
-logger.setLevel(logging.DEBUG)
+logger = utils.get_logger(__name__)
 
 # get DB controller
 db_controller = kv_store.DBController()

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/simplyblock_core/storage_node_ops.py

@@ -95,35 +95,40 @@ def addNvmeDevices(cluster, rpc_client, devs, snode):
 
         if pcie in ctr_map:
             nvme_controller = ctr_map[pcie]
+            nvme_bdevs = []
+            for bdev in rpc_client.get_bdevs():
+                if bdev['name'].startswith(nvme_controller):
+                    nvme_bdevs.append(bdev['name'])
         else:
-            nvme_controller = "nvme_%s" % index
-            ret, err = rpc_client.bdev_nvme_controller_attach(nvme_controller, pcie)
+            pci_st = str(pcie).replace("0", "").replace(":", "").replace(".", "")
+            nvme_controller = "nvme_%s" % pci_st
+            nvme_bdevs, err = rpc_client.bdev_nvme_controller_attach(nvme_controller, pcie)
             time.sleep(2)
 
-        nvme_bdev = f"{nvme_controller}n1"
-        rpc_client.bdev_examine(nvme_bdev)
-        time.sleep(5)
-        ret = rpc_client.get_bdevs(nvme_bdev)
-        nvme_dict = ret[0]
-        nvme_driver_data = nvme_dict['driver_specific']['nvme'][0]
-        model_number = nvme_driver_data['ctrlr_data']['model_number']
-        total_size = nvme_dict['block_size'] * nvme_dict['num_blocks']
-
-        devices.append(
-            NVMeDevice({
-                'uuid': str(uuid.uuid4()),
-                'device_name': nvme_dict['name'],
-                'size': total_size,
-                'physical_label': next_physical_label,
-                'pcie_address': nvme_driver_data['pci_address'],
-                'model_id': model_number,
-                'serial_number': nvme_driver_data['ctrlr_data']['serial_number'],
-                'nvme_bdev': nvme_bdev,
-                'nvme_controller': nvme_controller,
-                'node_id': snode.get_id(),
-                'cluster_id': snode.cluster_id,
-                'status': NVMeDevice.STATUS_ONLINE
-        }))
+        for nvme_bdev in nvme_bdevs:
+            rpc_client.bdev_examine(nvme_bdev)
+            time.sleep(3)
+            ret = rpc_client.get_bdevs(nvme_bdev)
+            nvme_dict = ret[0]
+            nvme_driver_data = nvme_dict['driver_specific']['nvme'][0]
+            model_number = nvme_driver_data['ctrlr_data']['model_number']
+            total_size = nvme_dict['block_size'] * nvme_dict['num_blocks']
+
+            devices.append(
+                NVMeDevice({
+                    'uuid': str(uuid.uuid4()),
+                    'device_name': nvme_dict['name'],
+                    'size': total_size,
+                    'physical_label': next_physical_label,
+                    'pcie_address': nvme_driver_data['pci_address'],
+                    'model_id': model_number,
+                    'serial_number': nvme_driver_data['ctrlr_data']['serial_number'],
+                    'nvme_bdev': nvme_bdev,
+                    'nvme_controller': nvme_controller,
+                    'node_id': snode.get_id(),
+                    'cluster_id': snode.cluster_id,
+                    'status': NVMeDevice.STATUS_ONLINE
+            }))
         next_physical_label += 1
     return devices
 
@@ -601,40 +606,27 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
             logger.error(f"This node is part of another cluster: {node_info['cluster_id']}")
             return False
 
-    ec2_metadata = None
-    if "ec2_metadata" in node_info and node_info['ec2_metadata']:
-        ec2_metadata = node_info['ec2_metadata']
-        """"
-         "ec2_metadata": {
-              "accountId": "565979732541",
-              "architecture": "x86_64",
-              "availabilityZone": "eu-west-1a",
-              "billingProducts": [
-                "bp-6fa54006"
-              ],
-              "devpayProductCodes": null,
-              "imageId": "ami-08e592fbb0f535224",
-              "instanceId": "i-0ba9e766df57bc62c",
-              "instanceType": "m6id.large",
-              "kernelId": null,
-              "marketplaceProductCodes": null,
-              "pendingTime": "2024-03-24T19:39:14Z",
-              "privateIp": "172.31.23.236",
-              "ramdiskId": null,
-              "region": "eu-west-1",
-              "version": "2017-09-30"
-        }
-        """""
-        logger.debug(json.dumps(ec2_metadata,indent=2))
-        logger.info(f"EC2 Instance found: {ec2_metadata['instanceId']}")
-        logger.info(f"EC2 Instance type: {ec2_metadata['instanceType']}")
-        logger.info(f"EC2 Instance privateIp: {ec2_metadata['privateIp']}")
-        logger.info(f"EC2 Instance region: {ec2_metadata['region']}")
-
-        for node in db_controller.get_storage_nodes():
-            if node.ec2_instance_id and node.ec2_instance_id == ec2_metadata['instanceId']:
-                logger.error(f"Node already exists, try remove it first: {ec2_metadata['instanceId']}")
-                return False
+    cloud_instance = node_info['cloud_instance']
+    """"
+     "cloud_instance": {
+          "id": "565979732541",
+          "type": "m6id.large",
+          "cloud": "google",
+          "ip": "10.10.10.10",
+          "public_ip": "20.20.20.20",
+    }
+    """""
+    logger.debug(json.dumps(cloud_instance, indent=2))
+    logger.info(f"Instance id: {cloud_instance['id']}")
+    logger.info(f"Instance cloud: {cloud_instance['cloud']}")
+    logger.info(f"Instance type: {cloud_instance['type']}")
+    logger.info(f"Instance privateIp: {cloud_instance['ip']}")
+    logger.info(f"Instance public_ip: {cloud_instance['public_ip']}")
+
+    for node in db_controller.get_storage_nodes():
+        if node.cloud_instance_id and node.cloud_instance_id == cloud_instance['id']:
+            logger.error(f"Node already exists, try remove it first: {cloud_instance['id']}")
+            return False
 
     # Tune cpu maks parameters
     cpu_count = node_info["cpu_count"]
@@ -662,18 +654,19 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
         distrib_cpu_mask = utils.generate_mask(distrib_cpu_cores)
 
     # Calculate pool count
-    if ec2_metadata and ec2_metadata.get('instanceType'):
-        supported_type, storage_devices, device_size = utils.get_total_size_per_instance_type(ec2_metadata["instanceType"])
+    if cloud_instance['type']:
+        ins_type = cloud_instance['type']
+        supported_type, storage_devices, device_size = utils.get_total_size_per_instance_type(ins_type)
         if not supported_type:
-            logger.warning(f"Unsupported ec2 instance-type {ec2_metadata['instanceType']} for deployment")
+            logger.warning(f"Unsupported instance-type {ins_type} for deployment")
             if not number_of_devices:
-                logger.error(f"Unsupported ec2 instance-type {ec2_metadata['instanceType']} "
+                logger.error(f"Unsupported instance-type {ins_type} "
                              "for deployment, please specify --number-of-devices")
                 return False
         else:
             number_of_devices = storage_devices
     else:
-        logger.warning("Can not get ec2 instance type for this instance.")
+        logger.warning("Can not get instance type for this instance.")
         if not number_of_devices:
             logger.error("Unsupported instance type please specify --number-of-devices.")
             return False
@@ -696,7 +689,7 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
         logger.info(f"Total: {utils.humanbytes(memory_details['total'])}")
         logger.info(f"Free: {utils.humanbytes(memory_details['free'])}")
     else:
-        logger.error(f"Cannot get memory info from the ec2 instance.. Exiting")
+        logger.error(f"Cannot get memory info from the instance.. Exiting")
         return False
 
     satisfied, spdk_mem = utils.calculate_spdk_memory(minimum_hp_memory,
@@ -750,12 +743,9 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     snode.baseboard_sn = node_info['system_id']
     snode.system_uuid = node_info['system_id']
 
-    if ec2_metadata:
-        snode.ec2_metadata = ec2_metadata
-        snode.ec2_instance_id = ec2_metadata['instanceId']
-
-    if "ec2_public_ip" in node_info and node_info['ec2_public_ip']:
-        snode.ec2_public_ip = node_info['ec2_public_ip']
+    snode.cloud_instance_id = cloud_instance['id']
+    snode.cloud_instance_type = cloud_instance['type']
+    snode.cloud_instance_public_ip = cloud_instance['public_ip']
 
     snode.hostname = hostname
     snode.host_nqn = subsystem_nqn
@@ -904,7 +894,7 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
             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
+                return False
 
             dev.remote_bdev = f"{name}n1"
             idx = -1
@@ -979,6 +969,12 @@ def remove_storage_node(node_id, force_remove=False, force_migrate=False):
         if force_remove is False:
             return False
 
+    task_id = tasks_controller.get_active_node_restart_task(snode.cluster_id, snode.get_id())
+    if task_id:
+        logger.error(f"Restart task found: {task_id}, can not remove storage node")
+        if force_remove is False:
+            return False
+
     if snode.lvols:
         if force_migrate:
             for lvol_id in snode.lvols:
@@ -1076,6 +1072,12 @@ def restart_storage_node(
         if force is False:
             return False
 
+    task_id = tasks_controller.get_active_node_restart_task(snode.cluster_id, snode.get_id())
+    if task_id:
+        logger.error(f"Restart task found: {task_id}, can not restart storage node")
+        if force is False:
+            return False
+
     logger.info("Setting node state to restarting")
     old_status = snode.status
     snode.status = StorageNode.STATUS_RESTARTING
@@ -1088,7 +1090,7 @@ def restart_storage_node(
 
     snode_api = SNodeClient(snode.api_endpoint)
     node_info, _ = snode_api.info()
-    logger.info(f"Node info: {node_info}")
+    logger.debug(f"Node info: {node_info}")
 
     logger.info("Restarting SPDK")
 
@@ -1104,20 +1106,20 @@ def restart_storage_node(
         snode.spdk_image = img
 
     # Calculate pool count
-    if snode.ec2_metadata and snode.ec2_metadata.get('instanceType'):
-        supported_type, storage_devices, device_size = utils.get_total_size_per_instance_type(snode.ec2_metadata["instanceType"])
+    if snode.cloud_instance_type:
+        supported_type, storage_devices, device_size = utils.get_total_size_per_instance_type(snode.cloud_instance_type)
         if not supported_type:
-            logger.warning(f"Unsupported ec2 instance-type {snode.ec2_metadata['instanceType']} for deployment")
+            logger.warning(f"Unsupported instance-type {snode.cloud_instance_type} for deployment")
             if not number_of_devices:
                 if not snode.number_of_devices:
-                    logger.error(f"Unsupported ec2 instance-type {snode.ec2_metadata['instanceType']} "
+                    logger.error(f"Unsupported instance-type {snode.cloud_instance_type} "
                                  "for deployment, please specify --number-of-devices")
                     return False
                 number_of_devices = snode.number_of_devices
         else:
             number_of_devices = storage_devices
     else:
-        logger.warning("Can not get ec2 instance type for this instance..")
+        logger.warning("Can not get instance type for this instance..")
         if not number_of_devices:
             if snode.number_of_devices:
                 number_of_devices = snode.number_of_devices
@@ -1144,7 +1146,7 @@ def restart_storage_node(
         logger.info(f"Total: {utils.humanbytes(memory_details['total'])}")
         logger.info(f"Free: {utils.humanbytes(memory_details['free'])}")
     else:
-        logger.error(f"Cannot get memory info from the ec2 instance.. Exiting")
+        logger.error(f"Cannot get memory info from the instance.. Exiting")
 
     satisfied, spdk_mem = utils.calculate_spdk_memory(minimum_hp_memory,
                                                       minimum_sys_memory,
@@ -1297,10 +1299,15 @@ def restart_storage_node(
             if dev.status != 'online':
                 continue
             name = f"remote_{dev.alceml_bdev}"
+            ret = rpc_client.bdev_nvme_controller_list(name)
+            if ret:
+                logger.debug(f"controller found, removing")
+                rpc_client.bdev_nvme_detach_controller(name)
+                time.sleep(1)
             ret = rpc_client.bdev_nvme_attach_controller_tcp(name, dev.nvmf_nqn, dev.nvmf_ip, dev.nvmf_port)
             if not ret:
                 logger.warning(f"Failed to connect to device: {name}")
-                continue
+                return False
 
             dev.remote_bdev = f"{name}n1"
             idx = -1
@@ -1378,16 +1385,13 @@ def list_storage_nodes(is_json, cluster_id=None):
             "Management IP": node.mgmt_ip,
             "Devices": f"{total_devices}/{online_devices}",
             "LVols": f"{len(node.lvols)}",
-            # "Data NICs": "\n".join([d.if_name for d in node.data_nics]),
             "Status": node.status,
             "Health": node.health_check,
 
-            "EC2 ID": node.ec2_instance_id,
-            "EC2 Type": node.ec2_metadata['instanceType'] if node.ec2_metadata else "",
-            "EC2 Ext IP": node.ec2_public_ip,
+            "Cloud ID": node.cloud_instance_id,
+            "Cloud Type": node.cloud_instance_type,
+            "Ext IP": node.cloud_instance_public_ip,
 
-            # "Updated At": datetime.datetime.strptime(node.updated_at, "%Y-%m-%d %H:%M:%S.%f").strftime(
-            #     "%H:%M:%S, %d/%m/%Y"),
         })
 
     if not data:

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/simplyblock_core/utils.py

@@ -5,9 +5,11 @@ import os
 import random
 import re
 import string
+import sys
 
 import docker
 from prettytable import PrettyTable
+from graypy import GELFUDPHandler
 
 from simplyblock_core import constants
 from simplyblock_core import shell_utils
@@ -408,7 +410,20 @@ def get_host_arch():
     out, _, _ = shell_utils.run_command("uname -m")
     return out
 
+
 def decimal_to_hex_power_of_2(decimal_number):
     power_result = 2 ** decimal_number
     hex_result = hex(power_result)
     return hex_result
+
+
+def get_logger(name):
+    logger = logging.getLogger(name)
+    logger.setLevel(constants.LOG_LEVEL)
+    logger_handler = logging.StreamHandler(stream=sys.stdout)
+    logger_handler.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
+    logger.addHandler(logger_handler)
+
+    gelf_handler = GELFUDPHandler('0.0.0.0', constants.GELF_PORT)
+    logger.addHandler(gelf_handler)
+    return logger

{sbcli_pre-1.4.4 → sbcli_pre-1.4.6}/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_deployer
+    web_api_lvol, web_api_storage_node, web_api_pool, web_api_caching_node, web_api_snapshot
 from auth_middleware import token_required
 from simplyblock_core import constants
 
@@ -31,7 +31,6 @@ 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.4.4 → sbcli_pre-1.4.6}/simplyblock_web/blueprints/caching_node_ops.py

@@ -14,7 +14,7 @@ from flask import Blueprint
 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
 
 logger = logging.getLogger(__name__)
 logger.setLevel(logging.DEBUG)
@@ -392,3 +392,74 @@ def disconnect_all():
     logger.debug(out)
     logger.debug(err)
     return utils.get_response(ret_code)
+
+
+
+@bp.route('/make_gpt_partitions', methods=['POST'])
+def make_gpt_partitions_for_nbd():
+    nbd_device = '/dev/nbd0'
+    jm_percent = 10
+
+    try:
+        data = request.get_json()
+        nbd_device = data['nbd_device']
+        jm_percent = data['jm_percent']
+    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}",
+    ]
+
+    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.4.4 → sbcli_pre-1.4.6}/simplyblock_web/blueprints/caching_node_ops_k8s.py

@@ -14,7 +14,7 @@ from flask import request
 from kubernetes.client import ApiException
 from jinja2 import Environment, FileSystemLoader
 
-from simplyblock_core import constants
+from simplyblock_core import constants, shell_utils
 
 from simplyblock_web import utils, node_utils
 
@@ -111,6 +111,8 @@ def spdk_process_start():
     else:
         spdk_mem = 64096
 
+    spdk_mem_gega = int(spdk_mem / 1024)
+
     spdk_image = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE
     if node_utils.get_host_arch() == "aarch64":
         spdk_image = constants.SIMPLY_BLOCK_SPDK_CORE_IMAGE_ARM64
@@ -132,6 +134,7 @@ def spdk_process_start():
             'SPDK_IMAGE': spdk_image,
             'SPDK_CPU_MASK': spdk_cpu_mask,
             'SPDK_MEM': spdk_mem,
+            'MEM_GEGA': spdk_mem_gega,
             'SERVER_IP': data['server_ip'],
             'RPC_PORT': data['rpc_port'],
             'RPC_USERNAME': data['rpc_username'],
@@ -277,3 +280,75 @@ def disconnect_all():
     logger.debug(out)
     logger.debug(err)
     return utils.get_response(ret_code)
+
+
+
+
+@bp.route('/make_gpt_partitions', methods=['POST'])
+def make_gpt_partitions_for_nbd():
+    nbd_device = '/dev/nbd0'
+    jm_percent = 10
+
+    try:
+        data = request.get_json()
+        nbd_device = data['nbd_device']
+        jm_percent = data['jm_percent']
+    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}",
+    ]
+
+    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)