sbcli-pre 1.2.5__zip → 1.2.7__zip

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

@@ -98,11 +98,19 @@ 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)
@@ -113,6 +121,12 @@ 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:
@@ -125,20 +139,15 @@ class DBController:
             if node.hostname == hostname:
                 return node
 
-    def get_storage_devices(self, id=""):
-        # workaround because nvme devices are stored inside the node object itself.
+    def get_storage_device_by_id(self, id):
         nodes = self.get_storage_nodes()
-        devices = []
-        device = None
         for node in nodes:
-            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
+            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)
 
     # Compute node functions
     def get_compute_node_by_id(self, id):
@@ -150,9 +159,15 @@ class DBController:
         ret = ComputeNode().read_from_db(self.kv_store)
         return ret
 
-    def get_pools(self):
-        ret = Pool().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_pool_by_id(self, id):
         ret = Pool().read_from_db(self.kv_store, id)
@@ -165,9 +180,16 @@ class DBController:
             if pool.pool_name == name:
                 return pool
 
-    def get_lvols(self):
-        ret = LVol().read_from_db(self.kv_store)
-        return ret
+    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_snapshots(self):
         ret = SnapShot().read_from_db(self.kv_store)
@@ -259,5 +281,25 @@ 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):
-        return JobSchedule().read_from_db(self.kv_store, id=cluster_id, reverse=True)
+    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_snapshots_by_node_id(self, node_id):
+        ret = []
+        snaps = SnapShot().read_from_db(self.kv_store)
+        for snap in snaps:
+            if snap.lvol.host_id == node_id:
+                ret.append(snap)
+        return ret
+
+    def get_snode_size(self, node_id):
+        snode = self.get_storage_node_by_id(node_id)
+        total_node_capacity = 0
+        for dev in snode.nvme_devices:
+            total_node_capacity += dev.size
+        return total_node_capacity

sbcli_pre-1.2.7/simplyblock_core/mgmt_node_ops.py

@@ -0,0 +1,205 @@
+# coding=utf-8
+import json
+import logging
+import uuid
+import time
+import requests
+
+import docker
+
+from simplyblock_core import utils, scripts
+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 deploy_mgmt_node(cluster_ip, cluster_id, ifname):
+
+    try:
+        resp = requests.get(f"http://{cluster_ip}/cluster/{cluster_id}")
+        resp_json = resp.json()
+        cluster_data = resp_json['results'][0]
+        logger.info(f"Cluster found! NQN:{cluster_data['nqn']}")
+        logger.debug(cluster_data)
+    except Exception as e:
+        logger.error("Error getting cluster data!")
+        logger.error(e)
+        return ""
+
+    logger.info("Installing dependencies...")
+    scripts.install_deps()
+    logger.info("Installing dependencies > Done")
+
+    if not ifname:
+        ifname = "eth0"
+
+    DEV_IP = utils.get_iface_ip(ifname)
+    if not DEV_IP:
+        logger.error(f"Error getting interface ip: {ifname}")
+        return False
+
+    logger.info(f"Node IP: {DEV_IP}")
+    ret = scripts.configure_docker(DEV_IP)
+
+    db_connection = cluster_data['db_connection']
+    scripts.set_db_config(db_connection)
+    time.sleep(1)
+    hostname = utils.get_hostname()
+    db_controller = DBController()
+    nodes = db_controller.get_mgmt_nodes(cluster_id=cluster_id)
+    if not nodes:
+        logger.error("No mgmt nodes was found in the cluster!")
+        return False
+    for node in nodes:
+        if node.hostname == hostname:
+            logger.error("Node already exists in the cluster")
+            return False
+
+    logger.info("Joining docker swarm...")
+    try:
+        cluster_docker = utils.get_docker_client(cluster_id)
+        docker_ip = cluster_docker.info()["Swarm"]["NodeAddr"]
+        join_token = cluster_docker.swarm.attrs['JoinTokens']['Manager']
+        node_docker = docker.DockerClient(base_url=f"tcp://{DEV_IP}:2375", version="auto")
+        if node_docker.info()["Swarm"]["LocalNodeState"] == "active":
+            logger.info("Node is part of another swarm, leaving swarm")
+            try:
+                cluster_docker.nodes.get(node_docker.info()["Swarm"]["NodeID"]).remove(force=True)
+            except:
+                pass
+            node_docker.swarm.leave(force=True)
+            time.sleep(5)
+
+        node_docker.swarm.join([f"{docker_ip}:2377"], join_token)
+
+        retries = 10
+        while retries > 0:
+            if node_docker.info()["Swarm"]["LocalNodeState"] == "active":
+                break
+            logger.info("Waiting for node to be active...")
+            retries -= 1
+            time.sleep(2)
+        logger.info("Joining docker swarm > Done")
+        time.sleep(5)
+
+    except Exception as e:
+        raise e
+
+    logger.info("Adding management node object")
+    node_id = add_mgmt_node(DEV_IP, cluster_id)
+
+    # check if ha setting is required
+    nodes = db_controller.get_mgmt_nodes(cluster_id=cluster_id)
+    if len(nodes) >= 3:
+        logger.info("Waiting for FDB container to be active...")
+        fdb_cont = None
+        retries = 30
+        while retries > 0 and fdb_cont is None:
+            logger.info("Looking for FDB container...")
+            for cont in node_docker.containers.list(all=True):
+                logger.debug(cont.attrs['Name'])
+                if cont.attrs['Name'].startswith("/app_fdb"):
+                    fdb_cont = cont
+                    break
+            if fdb_cont:
+                logger.info("FDB container found")
+                break
+            else:
+                retries -= 1
+                time.sleep(5)
+
+        if not fdb_cont:
+            logger.warning("FDB container was not found")
+        else:
+            retries = 10
+            while retries > 0:
+                info = node_docker.containers.get(fdb_cont.attrs['Id'])
+                status = info.attrs['State']["Status"]
+                is_running = info.attrs['State']["Running"]
+                if not is_running:
+                    logger.info("Container is not running, waiting...")
+                    time.sleep(3)
+                    retries -= 1
+                else:
+                    logger.info(f"Container status: {status}, Is Running: {is_running}")
+                break
+
+        logger.info("Configuring Double DB...")
+        time.sleep(3)
+        scripts.set_db_config_double()
+        for cl in db_controller.get_clusters():
+            cl.ha_type = "ha"
+            cl.write_to_db(db_controller.kv_store)
+
+    logger.info("Node joined the cluster")
+    return node_id
+
+
+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 node.uuid
+
+
+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 → sbcli_pre-1.2.7}/simplyblock_core/models/events.py

@@ -1,4 +1,6 @@
 # coding=utf-8
+from datetime import datetime
+
 from simplyblock_core.models.base_model import BaseModel
 
 
@@ -25,7 +27,7 @@ class EventObj(BaseModel):
         "uuid": {"type": str, 'default': ""},
         "cluster_uuid": {"type": str, 'default': ""},
         "node_id": {"type": str, 'default': ""},
-        "date": {"type": int, 'default': 0},
+        "date": {"type": int, 'default': 0},  # in milliseconds
 
         "event_level": {"type": str, 'default': LEVEL_INFO},
 
@@ -49,3 +51,9 @@ 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.5 → sbcli_pre-1.2.7}/simplyblock_core/models/job_schedule.py

@@ -8,6 +8,10 @@ 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': ""},
@@ -15,6 +19,8 @@ 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.5 → sbcli_pre-1.2.7}/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': ""},
-        "alloc_bdev": {"type": str, 'default': ""},
+        "nvme_controller": {"type": str, 'default': ""},
         "alceml_bdev": {"type": str, 'default': ""},
         "node_id": {"type": str, 'default': ""},
         "pt_bdev": {"type": str, 'default': ""},
@@ -37,7 +37,6 @@ 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': ""},
@@ -47,6 +46,13 @@ 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):
@@ -57,5 +63,37 @@ class NVMeDevice(BaseModel):
     def get_id(self):
         return self.uuid
 
-    def get_capacity_percentage(self):
-        return ((self.size - self.capacity) / self.size) * 100
+
+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
+

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/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
+from simplyblock_core.models.nvme_device import NVMeDevice, JMDevice
 
 
 class StorageNode(BaseModel):
@@ -61,7 +61,9 @@ class StorageNode(BaseModel):
         "remote_devices": {"type": List[NVMeDevice], 'default': []},
         "host_secret": {"type": str, "default": ""},
         "ctrl_secret": {"type": str, "default": ""},
-
+        "max_lvol": {"type": int, "default": 0},
+        "max_snap": {"type": int, "default": 0},
+        "max_prov": {"type": str, "default": ""},
         "cpu": {"type": int, "default": 0},
         "cpu_hz": {"type": int, "default": 0},
         "memory": {"type": int, "default": 0},
@@ -70,10 +72,16 @@ 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": []},
+        "nvme_pollers_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},
 
+
         "ec2_metadata": {"type": dict, "default": {}},
         "ec2_instance_id": {"type": str, "default": ""},
         "ec2_public_ip": {"type": str, "default": ""},
@@ -84,6 +92,10 @@ 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.5 → sbcli_pre-1.2.7}/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, alloc_bdev, vuid, pt_name):
+    def ultra21_bdev_pass_create(self, base_bdev, vuid, pt_name):
         params = {
-            "base_bdev": alloc_bdev,
+            "base_bdev": base_bdev,
             "vuid": vuid,
             "pt_bdev": pt_name
         }
@@ -318,7 +318,8 @@ 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):
+    def bdev_alceml_create(self, alceml_name, nvme_name, uuid, pba_init_mode=3,
+                           dev_cpu_mask=""):
         params = {
             "name": alceml_name,
             "cntr_path": nvme_name,
@@ -334,10 +335,13 @@ 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):
+                            chunk_size, ha_comm_addrs=None, ha_inode_self=None, pba_page_size=2097152,
+                            dev_cpu_mask=""):
         """"
             // Optional (not specified = no HA)
             // Comma-separated communication addresses, for each node, e.g. "192.168.10.1:45001,192.168.10.1:32768".
@@ -363,6 +367,8 @@ 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)
 
@@ -386,7 +392,7 @@ class RPCClient:
         params = {
             "name": name,
             "raid_level": "0",
-            "strip_size_kb": 4 * len(bdevs_list),
+            "strip_size_kb": 4,
             "base_bdevs": bdevs_list
         }
         return self._request("bdev_raid_create", params)
@@ -428,8 +434,9 @@ class RPCClient:
             "trsvcid": str(port),
             "subnqn": nqn,
             "fabrics_connect_timeout_us": 100000,
-            "fast_io_fail_timeout_sec": 0,
+            "fast_io_fail_timeout_sec": 1,
             "num_io_queues": 16384,
+            "ctrlr_loss_timeout_sec": 2,
         }
         return self._request("bdev_nvme_attach_controller", params)
 
@@ -477,9 +484,9 @@ class RPCClient:
         params = {
             "bdev_retry_count": 0,
             "transport_retry_count": 0,
-            "ctrlr_loss_timeout_sec": -1,
-            "fast_io_fail_timeout_sec": 5,
-            "reconnect_delay_sec": 5,
+            "ctrlr_loss_timeout_sec": 2,
+            "fast_io_fail_timeout_sec": 1,
+            "reconnect_delay_sec": 1,
             "keep_alive_timeout_ms": 200,
             "transport_ack_timeout": 7,
             "timeout_us": 100000
@@ -583,12 +590,14 @@ class RPCClient:
         }
         return self._request("ultra21_lvol_dismount", params)
 
-    def bdev_jm_create(self, name, name_storage1, block_size=4096):
+    def bdev_jm_create(self, name, name_storage1, block_size=4096, dev_cpu_mask=""):
         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):
@@ -620,6 +629,42 @@ 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)

{sbcli_pre-1.2.5 → sbcli_pre-1.2.7}/simplyblock_core/scripts/__init__.py

@@ -35,10 +35,6 @@ def deploy_stack(cli_pass, dev_ip, image_name, graylog_password, cluster_id, log
     return __run_script(
         ['sudo', 'bash', '-x', os.path.join(DIR_PATH, 'deploy_stack.sh'), cli_pass, dev_ip, image_name, pass_hash, graylog_password, cluster_id, log_del_interval, metrics_retention_period])
 
-def apply_dashboard(grafanaPassword):
-    return __run_script(
-        ['sudo', 'bash', '-x', os.path.join(DIR_PATH, 'apply_dashboard.sh'), grafanaPassword])
-
 
 def deploy_cleaner():
     return __run_script(['sudo', 'bash', '-x', os.path.join(DIR_PATH, 'clean_local_storage_deploy.sh')])