sbcli-dev 4.0.3__zip → 4.0.5__zip

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sbcli-dev
-Version: 4.0.3
+Version: 4.0.5
 Summary: CLI for managing SimplyBlock cluster
 Home-page: https://www.simplyblock.io/
 Author: Hamdy

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-dev
-SIMPLY_BLOCK_VERSION=4.0.3
+SIMPLY_BLOCK_VERSION=4.0.5
 
 
 SIMPLY_BLOCK_DOCKER_IMAGE=simplyblock/simplyblock:main-dev

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/sbcli_dev.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sbcli-dev
-Version: 4.0.3
+Version: 4.0.5
 Summary: CLI for managing SimplyBlock cluster
 Home-page: https://www.simplyblock.io/
 Author: Hamdy

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_core/constants.py

@@ -100,3 +100,6 @@ INSTANCE_STORAGE_DATA = {
     }
 
 MAX_SNAP_COUNT = 15
+
+SPDK_PROXY_MULTI_THREADING_ENABLED=False
+SPDK_PROXY_TIMEOUT=60*5

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_core/controllers/device_controller.py

@@ -38,6 +38,19 @@ def device_set_state(device_id, state):
     old_status = dev.status
     device.status = state
     snode.write_to_db(db_controller.kv_store)
+
+    if state == NVMeDevice.STATUS_ONLINE:
+        snode = db_controller.get_storage_node_by_id(dev.node_id)
+        logger.info("Make other nodes connect to the node devices")
+        snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
+        for node in snodes:
+            if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
+                continue
+            node.remote_devices = storage_node_ops._connect_to_remote_devs(node)
+            if node.enable_ha_jm:
+                node.remote_jm_devices = storage_node_ops._connect_to_remote_jm_devs(node)
+            node.write_to_db()
+
     distr_controller.send_dev_status_event(device, device.status)
     device_events.device_status_change(device, device.status, old_status)
     return True
@@ -80,19 +93,6 @@ def device_set_read_only(device_id):
 
 
 def device_set_online(device_id):
-    db_controller = DBController()
-    dev = db_controller.get_storage_devices(device_id)
-    snode = db_controller.get_storage_node_by_id(dev.node_id)
-    logger.info("Make other nodes connect to the node devices")
-    snodes = db_controller.get_storage_nodes_by_cluster_id(snode.cluster_id)
-    for node in snodes:
-        if node.get_id() == snode.get_id() or node.status != StorageNode.STATUS_ONLINE:
-            continue
-        node.remote_devices = storage_node_ops._connect_to_remote_devs(node)
-        if node.enable_ha_jm:
-            node.remote_jm_devices = storage_node_ops._connect_to_remote_jm_devs(node)
-        node.write_to_db()
-
     ret = device_set_state(device_id, NVMeDevice.STATUS_ONLINE)
     if ret:
         logger.info("Adding task to device data migration")

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_core/controllers/tasks_controller.py

@@ -80,8 +80,7 @@ def add_device_mig_task(device_id):
 
 
 def add_device_to_auto_restart(device):
-    return True
-    # return _add_task(JobSchedule.FN_DEV_RESTART, device.cluster_id, device.node_id, device.get_id())
+    return _add_task(JobSchedule.FN_DEV_RESTART, device.cluster_id, device.node_id, device.get_id())
 
 
 def add_node_to_auto_restart(node):

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_core/services/spdk_http_proxy_server.py

@@ -13,7 +13,6 @@ from http.server import ThreadingHTTPServer
 from http.server import BaseHTTPRequestHandler
 
 
-TIMEOUT = 5*60  # 5 min
 rpc_sock = '/var/tmp/spdk.sock'
 logger_handler = logging.StreamHandler(stream=sys.stdout)
 logger_handler.setFormatter(logging.Formatter('%(asctime)s: %(levelname)s: %(message)s'))
@@ -34,7 +33,7 @@ def get_env_var(name, default=None, is_required=False):
 
 def rpc_call(req):
     req_data = json.loads(req.decode('ascii'))
-    print(req_data)
+    logger.debug(f"Request data: {str(req_data)}")
     sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
     sock.settimeout(TIMEOUT)
     sock.connect(rpc_sock)
@@ -64,7 +63,7 @@ def rpc_call(req):
     if not response and len(buf) > 0:
         raise
 
-    print(buf)
+    logger.debug(f"Response data: {buf}")
 
     return buf
 
@@ -122,24 +121,28 @@ class ServerHandler(BaseHTTPRequestHandler):
                 self.do_INTERNALERROR()
 
 
-def run_server(host, port, user, password, cert=None):
+def run_server(host, port, user, password, cert=None, is_threading_enabled=False):
     # encoding user and password
     key = base64.b64encode((user+':'+password).encode(encoding='ascii')).decode('ascii')
 
     try:
         ServerHandler.key = key
-        # httpd = ThreadingHTTPServer((host, port), ServerHandler)
-        httpd = HTTPServer((host, port), ServerHandler)
+        if is_threading_enabled:
+            httpd = ThreadingHTTPServer((host, port), ServerHandler)
+        else:
+            httpd = HTTPServer((host, port), ServerHandler)
         httpd.timeout = TIMEOUT
         if cert is not None:
             httpd.socket = ssl.wrap_socket(httpd.socket, certfile=cert, server_side=True)
-        print('Started RPC http proxy server')
+        logger.info('Started RPC http proxy server')
         httpd.serve_forever()
     except KeyboardInterrupt:
-        print('Shutting down server')
+        logger.info('Shutting down server')
         httpd.socket.close()
 
 
+TIMEOUT = int(get_env_var("TIMEOUT", is_required=False, default=60*5))
+is_threading_enabled = get_env_var("MULTI_THREADING_ENABLED", is_required=False, default=False)
 server_ip = get_env_var("SERVER_IP", is_required=True)
 rpc_port = get_env_var("RPC_PORT", is_required=True)
 rpc_username = get_env_var("RPC_USERNAME", is_required=True)
@@ -150,4 +153,5 @@ try:
 except Exception:
     rpc_port = 8080
 
-run_server(server_ip, rpc_port, rpc_username, rpc_password)
+is_threading_enabled = bool(is_threading_enabled)
+run_server(server_ip, rpc_port, rpc_username, rpc_password, is_threading_enabled=is_threading_enabled)

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_core/snode_client.py

@@ -72,7 +72,7 @@ class SNodeClient:
 
     def spdk_process_start(self, spdk_cpu_mask, spdk_mem, spdk_image=None, spdk_debug=None, cluster_ip=None,
                            fdb_connection=None, namespace=None, server_ip=None, rpc_port=None,
-                           rpc_username=None, rpc_password=None):
+                           rpc_username=None, rpc_password=None, multi_threading_enabled=False, timeout=0):
         params = {
             "cluster_ip": cluster_ip,
             "server_ip": server_ip,
@@ -92,6 +92,10 @@ class SNodeClient:
             params['fdb_connection'] = fdb_connection
         if namespace:
             params["namespace"] = namespace
+        if multi_threading_enabled:
+            params["multi_threading_enabled"] = multi_threading_enabled
+        if timeout:
+            params["timeout"] = timeout
         return self._request("POST", "spdk_process_start", params)
 
     def join_swarm(self, cluster_ip, join_token, db_connection, cluster_id):

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_core/storage_node_ops.py

@@ -790,7 +790,10 @@ def _connect_to_remote_jm_devs(this_node, jm_ids=[]):
         this_node.rpc_username, this_node.rpc_password, timeout=10, retry=2)
 
     node_bdevs = rpc_client.get_bdevs()
-    node_bdev_names = [b['name'] for b in node_bdevs]
+    if node_bdevs:
+        node_bdev_names = [b['name'] for b in node_bdevs]
+    else:
+        node_bdev_names = []
     remote_devices = []
     if jm_ids:
         for jm_id in jm_ids:
@@ -1001,7 +1004,8 @@ def add_node(cluster_id, node_ip, iface_name, data_nics_list,
     try:
         results, err = snode_api.spdk_process_start(
             spdk_cpu_mask, spdk_mem, spdk_image, spdk_debug, cluster_ip, fdb_connection,
-            namespace, mgmt_ip, constants.RPC_HTTP_PROXY_PORT, rpc_user, rpc_pass)
+            namespace, mgmt_ip, constants.RPC_HTTP_PROXY_PORT, rpc_user, rpc_pass,
+            multi_threading_enabled=constants.SPDK_PROXY_MULTI_THREADING_ENABLED, timeout=constants.SPDK_PROXY_TIMEOUT)
     except Exception as e:
         logger.error(e)
         return False
@@ -1532,7 +1536,8 @@ def restart_storage_node(
         fdb_connection = cluster.db_connection
         results, err = snode_api.spdk_process_start(
             snode.spdk_cpu_mask, spdk_mem, snode.spdk_image, spdk_debug, cluster_ip, fdb_connection,
-            snode.namespace, snode.mgmt_ip, constants.RPC_HTTP_PROXY_PORT, snode.rpc_username, snode.rpc_password)
+            snode.namespace, snode.mgmt_ip, constants.RPC_HTTP_PROXY_PORT, snode.rpc_username, snode.rpc_password,
+            multi_threading_enabled=constants.SPDK_PROXY_MULTI_THREADING_ENABLED, timeout=constants.SPDK_PROXY_TIMEOUT)
     except Exception as e:
         logger.error(e)
         return False

{sbcli_dev-4.0.3 → sbcli_dev-4.0.5}/simplyblock_web/blueprints/snode_ops.py

@@ -96,6 +96,17 @@ def spdk_process_start():
     if 'spdk_mem' in data:
         spdk_mem = data['spdk_mem']
 
+    multi_threading_enabled = False
+    if 'multi_threading_enabled' in data:
+        multi_threading_enabled = bool(data['multi_threading_enabled'])
+
+    timeout = 60*5
+    if 'timeout' in data:
+        try:
+            timeout = int(data['timeout'])
+        except:
+            pass
+
     if spdk_mem:
         spdk_mem = int(utils.parse_size(spdk_mem) / (1000 * 1000))
     else:
@@ -157,6 +168,8 @@ def spdk_process_start():
             f"RPC_PORT={data['rpc_port']}",
             f"RPC_USERNAME={data['rpc_username']}",
             f"RPC_PASSWORD={data['rpc_password']}",
+            f"MULTI_THREADING_ENABLED={multi_threading_enabled}",
+            f"TIMEOUT={timeout}",
         ]
         # restart_policy={"Name": "always"}
     )