statbtrfs 0.20__py3-none-any.whl

statbtrfs-0.20.dist-info/METADATA

@@ -0,0 +1,44 @@
+Metadata-Version: 2.2
+Name: statbtrfs
+Version: 0.20
+Summary: Query Btrfs filesystem status
+Home-page: https://github.com/yufei-pan/statbtrfs
+Author: Yufei Pan
+Author-email: pan@zopyr.us
+License: GPLv3+
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: GNU General Public License v3 or later (GPLv3+)
+Classifier: Operating System :: POSIX :: Linux
+Requires-Python: >=3.6
+Description-Content-Type: text/plain
+Requires-Dist: prettytable
+Requires-Dist: multiCMD
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+usage: statbtrfs [-h] [-s] [-i INTERVAL] [-m MAX_SCRUB_COUNT] [--scrub_command_lockout SCRUB_COMMAND_LOCKOUT] [-V]
+
+Check Btrfs filesystem status.
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -s, --scrub           Issue scrub to all pools
+  -i INTERVAL, --interval INTERVAL
+                        Interval for status check in seconds
+  -m MAX_SCRUB_COUNT, --max_scrub_count MAX_SCRUB_COUNT
+                        Maximum number of scrubs to issue at the same time
+  --scrub_command_lockout SCRUB_COMMAND_LOCKOUT
+                        Lockout for scrub command. Used to block two commands sent quickly.
+  -V, --version         show program's version number and exit
+
+
+Install:
+sudo pip install statbtrfs

statbtrfs-0.20.dist-info/RECORD

@@ -0,0 +1,6 @@
+statbtrfs.py,sha256=oRLzmAzIFKQxCI5MvjXjOgRsSnqrhSuF4lEN9y1UKAg,8985
+statbtrfs-0.20.dist-info/METADATA,sha256=oEPpduTfma9HlmIXdQndi3-4VxpM3DOFPg_-euSd5zY,1451
+statbtrfs-0.20.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+statbtrfs-0.20.dist-info/entry_points.txt,sha256=vYrh-WMvmuKpaknUzxQAIn2d9r0fGqhJw1HBk3JqKxg,45
+statbtrfs-0.20.dist-info/top_level.txt,sha256=5aCdt8cDgGV1-phlf6AZdHrUb1xV5OxgXwdiyE_qn4o,10
+statbtrfs-0.20.dist-info/RECORD,,

statbtrfs-0.20.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (75.8.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

statbtrfs-0.20.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+statbtrfs = statbtrfs:main

statbtrfs-0.20.dist-info/top_level.txt

@@ -0,0 +1 @@
+statbtrfs

statbtrfs.py

@@ -0,0 +1,230 @@
+#!/usr/bin/env python3
+from prettytable import PrettyTable
+import argparse
+import time
+import os
+import sys
+import fnmatch
+import multiCMD
+
+version='0.20'
+
+# Colors
+RED = "\033[91m"
+GREEN = "\033[92m"
+YELLOW = "\033[93m"
+RESET = "\033[0m"
+
+USE_SUDO = True
+if os.geteuid() == 0:
+    USE_SUDO = False
+
+if USE_SUDO:
+    #check if sudo is available
+    if multiCMD.run_command(['which','sudo'],quiet=True,return_code_only=True):
+        print(f"{RED}sudo is required to run this script.{RESET}")
+        sys.exit(1)
+
+def execute_command(command,wait=True):
+    if USE_SUDO:
+        command = ['sudo'] + command
+    return multiCMD.run_command(command,quiet=True,wait_for_return=wait)
+
+def find_btrfs_mounts(filters):
+    mounts = execute_command(["mount", "-t", "btrfs"])
+    #mounts = multiCMD.run_command(["mount", "-t", "btrfs"],quiet=True)
+    btrfs_mounts = set()
+    if mounts:
+        if filters:
+            filters = [f'*{filter}*' for filter in filters]
+            mount_list = [line.split()[2] for line in mounts]
+            for filter in filters:
+                btrfs_mounts.update(fnmatch.filter(mount_list,filter))
+        else:
+            btrfs_mounts.update([line.split()[2] for line in mounts])
+    return btrfs_mounts
+
+def parse_show_info(info):
+    fs_used = None
+    device_path = None
+    uuid = None
+    for line in info:
+        if "uuid:" in line:
+            uuid = line.split("uuid:")[1].split()[0].strip()
+        if "Total devices" in line:
+            fs_used = line.split("FS bytes used")[1].strip()
+        if "path" in line:
+            device_path = line.split("path")[1].strip()
+    if fs_used is None or device_path is None or uuid is None:
+        print(f"{RED}Could not parse btrfs show info.{RESET}")
+        print(f"Output from btrfs filesystem show was:\n{info}")
+    return uuid, fs_used, device_path
+
+def parse_device_stats(stats):
+    err_dict = {}
+    for line in stats:
+        key, val = line.split()
+        err_dict[key.split(".")[-1]] = val
+    return err_dict
+
+def color_error_count(error_count):
+    if int(error_count) == 0:
+        return f"{GREEN}{error_count}{RESET}"
+    elif int(error_count) < 10:
+        return f"{YELLOW}{error_count}{RESET}"
+    else:
+        return f"{RED}{error_count}{RESET}"
+
+def parse_scrub_status(output):
+    scrub_data = {}
+    lines = output
+    # if "no stats available" in output:
+    #     scrub_data = {
+    #         "scrub_status": "Never",
+    #         "scrub_time": "N/A",
+    #         "scrub_rate": "N/A",
+    #         "scrubbed_data": "N/A",
+    #         "error_summary": "N/A"
+    #     }
+    # else:
+    scrub_data = {
+        "scrub_status": "Never",
+        "scrub_time": "N/A",
+        "scrub_rate": "N/A",
+        "scrubbed_data": "N/A",
+        "error_summary": "N/A"
+    }
+    for line in lines:
+        if "Status:" in line:
+            scrub_data["scrub_status"] = line.split(":")[1].strip()
+        elif "Scrub started:" in line:
+            scrub_data["scrub_time"] = line.split(":")[1].strip()
+        elif "Rate:" in line:
+            scrub_data["scrub_rate"] = line.split(":")[1].strip()
+        elif "Total to scrub:" in line and scrub_data.get("scrub_status") != "running":
+            scrub_data["scrubbed_data"] = line.split(":")[1].strip()
+        elif "Bytes scrubbed:" in line and scrub_data.get("scrub_status") == "running":
+            scrub_data["scrubbed_data"] = line.split(":")[1].strip()
+        elif "Error summary:" in line:
+            err_idx = lines.index(line)
+            error_text = "\n".join(lines[err_idx:])
+            if "no errors found" in error_text.lower():
+                scrub_data["error_summary"] = f"{GREEN}OK{RESET}"  # Green-colored OK
+            else:
+                scrub_data["error_summary"] = F"{RED}{error_text}{RESET}"
+
+    return scrub_data
+
+def issue_scrub_command(mounts):
+    # print(f"{YELLOW}Issuing scrub on {mount}{RESET}")
+    # execute_command(['bash','-c',f"btrfs scrub start {mount}"],wait=False)
+    # limit the number of mounts to scrub to max_scrub_count
+    scrubed_mounts = []
+    for mount in mounts:
+        print(f"{YELLOW}Issuing scrub on {mount}{RESET}")
+        execute_command(['btrfs','scrub','start',mount],wait=False)
+        #multiCMD.run_command(['btrfs','scrub','start',mount],quiet=True)
+        scrubed_mounts.append(mount)
+        yield scrubed_mounts
+    return scrubed_mounts
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Check Btrfs filesystem status.")
+    parser.add_argument("-s", "--scrub", help="Issue scrub to all pools", action="store_true")
+    parser.add_argument("-i", "--interval", help="Interval for status check in seconds", default=2, type=int)
+    parser.add_argument("-m", "--max_scrub_count", help="Maximum number of scrubs to issue at the same time", default=32, type=int)
+    parser.add_argument("--scrub_command_lockout", help="Lockout for scrub command. Used to block two commands sent quickly.", default=10, type=int)
+    parser.add_argument('pattern',nargs='*',help='Patterns to filter btrfs moutns. Default="*"')
+    parser.add_argument('-V', '--version', action='version', version=f"%(prog)s {version} stat btrfs by pan@zopyr.us")
+    args = parser.parse_args()
+
+    btrfs_mounts = set(find_btrfs_mounts(args.pattern))
+
+    # If the scrub flag is enabled, issue the scrub command to all mounts
+    if args.scrub:
+        if args.max_scrub_count < 1:
+            scrub_count = os.cpu_count()
+        else:
+            scrub_count = args.max_scrub_count
+        if scrub_count > len(btrfs_mounts):
+            scrub_count = len(btrfs_mounts)
+        scrubber = issue_scrub_command(btrfs_mounts)
+        for i in range(scrub_count):
+            scrubed_mounts = next(scrubber)
+        print(f'Issued scrub to {GREEN}{scrubed_mounts}{RESET} mounts')
+        scrub_start_time = time.time()
+        #print(f'{GREEN}Scrub all issued!{RESET}')
+        time.sleep(args.interval)
+
+    
+    while True: 
+        table = PrettyTable()
+
+        table.field_names = ["Mount", "Path", "FS Used", "w_err", "r_err", "bit_rot", "gen_err",
+                            "scrub_status", "scrub_time", "scrub_rate", "scrubbed_data", "error_summary"]
+
+        if not btrfs_mounts:
+            print(f"{RED}No Btrfs mounts found.{RESET}")
+            return
+
+        for mount in btrfs_mounts:
+            mount_dir_name = mount.split("/")[-1]
+            if not mount_dir_name:
+                mount_dir_name = "/"
+            
+            filesystem_show = execute_command(["btrfs", "filesystem", "show", mount])
+            #filesystem_show = multiCMD.run_command(["btrfs", "filesystem", "show", mount],quiet=True)
+            uuid, fs_used, device_path = parse_show_info(filesystem_show)
+
+            if uuid is None or fs_used is None or device_path is None:
+                print(f"{RED}Could not fetch complete info for {mount}. Skipping...{RESET}")
+                continue
+
+            device_stats = execute_command(["btrfs", "device", "stats", mount])
+            #device_stats = multiCMD.run_command(["btrfs", "device", "stats", mount],quiet=True)
+            err_dict = parse_device_stats(device_stats)
+
+            scrub_output = execute_command(["btrfs", "scrub", "status", device_path])
+            #scrub_output = multiCMD.run_command(["btrfs", "scrub", "status", device_path],quiet=True)
+            scrub_data = parse_scrub_status(scrub_output)
+
+            table.add_row([
+                mount_dir_name,
+                device_path,
+                fs_used,
+                color_error_count(err_dict['write_io_errs']),
+                color_error_count(err_dict['read_io_errs']),
+                color_error_count(err_dict['corruption_errs']),
+                color_error_count(err_dict['generation_errs']),
+                scrub_data["scrub_status"],
+                scrub_data["scrub_time"],
+                scrub_data["scrub_rate"],
+                scrub_data["scrubbed_data"],
+                scrub_data["error_summary"]
+            ])
+
+        print(table)
+
+
+        if not args.scrub:
+            break
+
+        # Check if all scrubs are finished.
+        scrub_status_idx = table.field_names.index("scrub_status")
+        running_scrubs = [row[scrub_status_idx] == "running" for row in table._rows]
+        # issue scrub command to next mount if there are less than max_scrub_count scrubs running
+        if sum(running_scrubs) < scrub_count and time.time() - scrub_start_time > args.scrub_command_lockout and len(scrubed_mounts) < len(btrfs_mounts):
+            scrubed_mounts = next(scrubber)
+            # print(f'Issued scrub to {GREEN}{scrubed_mounts}{RESET} mounts')
+            print(f"{GREEN}Scrubed issued to {scrubed_mounts}.{RESET}")
+            scrub_start_time = time.time()
+
+        if sum(running_scrubs) == 0 and time.time() - scrub_start_time > args.scrub_command_lockout:
+            print(f"{GREEN}All Scrubs finished.{RESET}")
+            break
+
+        time.sleep(args.interval)
+
+if __name__ == "__main__":
+    main()