sbcli-pre 1.4.7__zip → 1.4.8__zip

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/PKG-INFO

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

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/env_var

@@ -1,5 +1,5 @@
 SIMPLY_BLOCK_COMMAND_NAME=sbcli-pre
-SIMPLY_BLOCK_VERSION=1.4.7
+SIMPLY_BLOCK_VERSION=1.4.8
 
 
 SIMPLY_BLOCK_DOCKER_IMAGE=simplyblock/simplyblock:pre-release

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/sbcli_pre.egg-info/PKG-INFO

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

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/sbcli_pre.egg-info/SOURCES.txt

@@ -85,6 +85,7 @@ simplyblock_core/scripts/dashboards/node-exporter.json
 simplyblock_core/scripts/dashboards/nodes.json
 simplyblock_core/scripts/dashboards/pools.json
 simplyblock_core/services/__init__.py
+simplyblock_core/services/cached_lvol_stat_collector.py
 simplyblock_core/services/caching_node_monitor.py
 simplyblock_core/services/cap_monitor.py
 simplyblock_core/services/capacity_and_stats_collector.py

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_cli/cli.py

@@ -609,9 +609,9 @@ class CLIWrapper:
         sub_command.add_argument("node_id", help='Caching node UUID')
 
         sub_command = self.add_sub_command(subparser, 'get-lvol-stats', 'Get LVol stats')
-        sub_command.add_argument("node_id", help='Caching node UUID')
         sub_command.add_argument("lvol_id", help='LVol UUID')
-        sub_command.add_argument("--duration", help='collection duration in seconds, default: 5', type=int, default=5)
+        sub_command.add_argument("--history", help='(XXdYYh), list history records (one for every 15 minutes) '
+                                                   'for XX days and YY hours (up to 10 days in total).')
 
 
     def init_parser(self):
@@ -1111,7 +1111,11 @@ class CLIWrapper:
                 ret = caching_node_controller.recreate(args.node_id)
 
             if sub_command == "get-lvol-stats":
-                ret = caching_node_controller.get_lvol_stats(args.node_id, args.lvol_id, args.duration)
+                data = caching_node_controller.get_io_stats(args.lvol_id, args.history)
+                if data:
+                    ret = utils.print_table(data)
+                else:
+                    return False
 
         else:
             self.parser.print_help()

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_core/constants.py

@@ -14,8 +14,8 @@ INSTALL_DIR = os.path.dirname(os.path.realpath(__file__))
 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
+LVOL_STAT_COLLECTOR_INTERVAL_SEC = 5
+LVOL_MONITOR_INTERVAL_SEC = 120
 DEV_MONITOR_INTERVAL_SEC = 10
 DEV_STAT_COLLECTOR_INTERVAL_SEC = 2
 PROT_STAT_COLLECTOR_INTERVAL_SEC = 2
@@ -23,6 +23,7 @@ DISTR_EVENT_COLLECTOR_INTERVAL_SEC = 2
 DISTR_EVENT_COLLECTOR_NUM_OF_EVENTS = 10
 CAP_MONITOR_INTERVAL_SEC = 30
 SSD_VENDOR_WHITE_LIST = ["1d0f:cd01", "1d0f:cd00"]
+CACHED_LVOL_STAT_COLLECTOR_INTERVAL_SEC = 5
 
 PMEM_DIR = '/tmp/pmem'
 

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_core/controllers/caching_node_controller.py

@@ -478,7 +478,7 @@ def connect(caching_node_id, lvol_id):
     logger.info(f"Device path: {dev_path}")
 
     cached_lvol = CachedLVol()
-    cached_lvol.uuid = str(uuid.uuid4())
+    cached_lvol.uuid = lvol.get_id()
     cached_lvol.lvol_id = lvol.get_id()
     cached_lvol.lvol = lvol
     cached_lvol.hostname = cnode.hostname
@@ -733,41 +733,40 @@ def remove_node(node_id, force=False):
     logger.info("done")
 
 
-def get_lvol_stats(caching_node_id, lvol_id, duration=5):
-    db_controller = DBController()
-    cnode = db_controller.get_caching_node_by_id(caching_node_id)
-    if not cnode:
-        logger.info(f"Caching node uuid not found: {caching_node_id}")
-        cnode = db_controller.get_caching_node_by_hostname(caching_node_id)
-        if not cnode:
-            logger.error("Caching node not found")
-            return False
-
-    lvol = db_controller.get_lvol_by_id(lvol_id)
+def get_io_stats(lvol_uuid, history, records_count=20, parse_sizes=True):
+    lvol = db_controller.get_lvol_by_id(lvol_uuid)
     if not lvol:
-        logger.error(f"LVol not found: {lvol_id}")
+        logger.error(f"LVol not found: {lvol_uuid}")
         return False
 
-    rpc_client = RPCClient(
-        cnode.mgmt_ip, cnode.rpc_port,
-        cnode.rpc_username, cnode.rpc_password,
-        timeout=3, retry=2)
-
-    ocf_bdev = None
-    for lv in cnode.lvols:
-        if lv.lvol_id == lvol.get_id():
-            ocf_bdev = lv.ocf_bdev
+    if history:
+        records_number = utils.parse_history_param(history)
+        if not records_number:
+            logger.error(f"Error parsing history string: {history}")
+            return False
+    else:
+        records_number = 20
 
-    if not ocf_bdev:
-        logger.error(f"LVol is not connected to caching node")
+    records_list = db_controller.get_cached_lvol_stats(lvol.get_id(), limit=records_number)
+    if not records_list:
         return False
+    new_records = utils.process_records(records_list, min(records_count, len(records_list)))
+
+    if not parse_sizes:
+        return new_records
+
+    out = []
+    for record in new_records:
+        out.append({
+            "Date": time.strftime("%Y-%m-%d %H:%M:%S", time.gmtime(record['date'])),
+            "Read bytes": utils.humanbytes(record["read_bytes"]),
+            "Read speed": utils.humanbytes(record['read_bytes_ps']),
+            "Read IOPS": record['read_io_ps'],
+            "Read lat": record['read_latency_ps'],
+            "Write bytes": utils.humanbytes(record["write_bytes"]),
+            "Write speed": utils.humanbytes(record['write_bytes_ps']),
+            "Write IOPS": record['write_io_ps'],
+            "Write lat": record['write_latency_ps'],
+        })
+    return out
 
-    logger.info("Getting bdev stats: %s", ocf_bdev)
-
-    while True:
-        stats_dict = rpc_client.get_lvol_stats(ocf_bdev)
-        print(datetime.datetime.now())
-        print(json.dumps(stats_dict, indent=2))
-        time.sleep(duration)
-
-    return True

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_core/controllers/lvol_controller.py

@@ -1345,7 +1345,9 @@ def get_io_stats(lvol_uuid, history, records_count=20, parse_sizes=True):
         records_number = 20
 
     records_list = db_controller.get_lvol_stats(lvol, limit=records_number)
-    new_records = utils.process_records(records_list, records_count)
+    if not records_list:
+        return False
+    new_records = utils.process_records(records_list, min(records_count, len(records_list)))
 
     if not parse_sizes:
         return new_records

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_core/kv_store.py

@@ -19,7 +19,7 @@ from simplyblock_core.models.mgmt_node import MgmtNode
 from simplyblock_core.models.pool import Pool
 from simplyblock_core.models.snapshot import SnapShot
 from simplyblock_core.models.stats import DeviceStatObject, NodeStatObject, ClusterStatObject, LVolStatObject, \
-    PoolStatObject
+    PoolStatObject, CachedLVolStatObject
 from simplyblock_core.models.storage_node import StorageNode
 from simplyblock_core.models.lvol_model import LVol
 
@@ -232,6 +232,10 @@ class DBController:
         stats = LVolStatObject().read_from_db(self.kv_store, id="%s/%s" % (lvol.pool_uuid, lvol.uuid), limit=limit, reverse=True)
         return stats
 
+    def get_cached_lvol_stats(self, lvol_id, limit=20):
+        stats = CachedLVolStatObject().read_from_db(self.kv_store, id="%s/%s" % (lvol_id, lvol_id), limit=limit, reverse=True)
+        return stats
+
     def get_pool_stats(self, pool, limit=20):
         stats = PoolStatObject().read_from_db(self.kv_store, id="%s/%s" % (pool.get_id(), pool.get_id()), limit=limit, reverse=True)
         return stats

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_core/models/stats.py

@@ -126,3 +126,7 @@ class LVolStatObject(StatsObject):
 
 class PoolStatObject(LVolStatObject):
     pass
+
+
+class CachedLVolStatObject(StatsObject):
+    pass

{sbcli_pre-1.4.7 → sbcli_pre-1.4.8}/simplyblock_core/scripts/docker-compose-swarm.yml

@@ -79,6 +79,17 @@ services:
     networks:
       - hostnet
 
+  CachedLVolStatsCollector:
+    image: $SIMPLYBLOCK_DOCKER_IMAGE
+    command: "python simplyblock_core/services/cached_lvol_stat_collector.py"
+    deploy:
+      placement:
+        constraints: [node.role == manager]
+    volumes:
+      - "/etc/foundationdb:/etc/foundationdb"
+    networks:
+      - hostnet
+
   PortStatsCollector:
     image: $SIMPLYBLOCK_DOCKER_IMAGE
     command: "python simplyblock_core/services/port_stat_collector.py"

sbcli_pre-1.4.8/simplyblock_core/services/cached_lvol_stat_collector.py

@@ -0,0 +1,89 @@
+# coding=utf-8
+import time
+
+from simplyblock_core import constants, kv_store, utils
+from simplyblock_core.models.stats import CachedLVolStatObject
+from simplyblock_core.rpc_client import RPCClient
+
+
+logger = utils.get_logger(__name__)
+
+last_object_record = {}
+
+
+def add_lvol_stats(lvol, stats_dict):
+    now = int(time.time())
+    data = {
+        "cluster_id": lvol.get_id(),
+        "uuid": lvol.get_id(),
+        "date": now}
+
+    if stats_dict and stats_dict['bdevs']:
+        stats = stats_dict['bdevs'][0]
+        data.update({
+            "read_bytes": stats['bytes_read'],
+            "read_io": stats['num_read_ops'],
+            "read_latency_ticks": stats['read_latency_ticks'],
+
+            "write_bytes": stats['bytes_written'],
+            "write_io": stats['num_write_ops'],
+            "write_latency_ticks": stats['write_latency_ticks'],
+
+            "unmap_bytes": stats['bytes_unmapped'],
+            "unmap_io": stats['num_unmap_ops'],
+            "unmap_latency_ticks": stats['unmap_latency_ticks'],
+        })
+
+        last_record = None
+        if lvol.get_id() in last_object_record:
+            last_record = last_object_record[lvol.get_id()]
+        else:
+            records = db_controller.get_cached_lvol_stats(lvol.get_id(), limit=1)
+            if records:
+                last_record = records[0]
+
+        if last_record:
+            time_diff = (now - last_record.date)
+            if time_diff > 0:
+                data['record_duration'] = time_diff
+                data['read_bytes_ps'] = int((data['read_bytes'] - last_record['read_bytes']) / time_diff)
+                data['read_io_ps'] = int((data['read_io'] - last_record['read_io']) / time_diff)
+                data['read_latency_ps'] = int(
+                    (data['read_latency_ticks'] - last_record['read_latency_ticks']) / time_diff)
+
+                data['write_bytes_ps'] = int((data['write_bytes'] - last_record['write_bytes']) / time_diff)
+                data['write_io_ps'] = int((data['write_io'] - last_record['write_io']) / time_diff)
+                data['write_latency_ps'] = int(
+                    (data['write_latency_ticks'] - last_record['write_latency_ticks']) / time_diff)
+
+                data['unmap_bytes_ps'] = int((data['unmap_bytes'] - last_record['unmap_bytes']) / time_diff)
+                data['unmap_io_ps'] = int((data['unmap_io'] - last_record['unmap_io']) / time_diff)
+                data['unmap_latency_ps'] = int(
+                    (data['unmap_latency_ticks'] - last_record['unmap_latency_ticks']) / time_diff)
+
+        else:
+            logger.warning("last record not found")
+    else:
+        logger.error("Error getting stats")
+
+    stat_obj = CachedLVolStatObject(data=data)
+    stat_obj.write_to_db(db_controller.kv_store)
+    last_object_record[lvol.get_id()] = stat_obj
+    return stat_obj
+
+
+db_store = kv_store.KVStore()
+db_controller = kv_store.DBController()
+
+logger.info("Starting stats collector...")
+while True:
+    cnodes = db_controller.get_caching_nodes()
+    for node in cnodes:
+        rpc_client = RPCClient(node.mgmt_ip, node.rpc_port, node.rpc_username, node.rpc_password, timeout=3, retry=1)
+        for cached_lvol in node.lvols:
+            logger.info("Getting lVol stats: %s", cached_lvol.uuid)
+            stats_dict = rpc_client.get_lvol_stats(cached_lvol.ocf_bdev)
+            add_lvol_stats(cached_lvol.lvol, stats_dict)
+
+    logger.info(f"Sleeping for {constants.CACHED_LVOL_STAT_COLLECTOR_INTERVAL_SEC} seconds")
+    time.sleep(constants.CACHED_LVOL_STAT_COLLECTOR_INTERVAL_SEC)