sysview-py 0.1.0__py3-none-any.whl

sysview_py/db.py

@@ -0,0 +1,122 @@
+import datetime
+import sqlite3
+
+
+class SysviewDB:
+    schema = """
+        CREATE TABLE hosts(name, UNIQUE(name));
+        CREATE TABLE types(name, UNIQUE(name));
+        CREATE TABLE hosts_types(host, type, UNIQUE(host, type));
+        CREATE TABLE reports(hostname, type, date, raw_report);
+        CREATE TABLE items(command, status, status_text, additional_text, raw_item, report_id);
+    """
+    def __init__(self, path):
+        self.path = path
+        self._connection = None
+        self._cursor = None
+
+    def connect(self):
+        db_exists = False
+        if self.path.exists():
+            db_exists = True
+        self._connection = sqlite3.connect(self.path)
+        self._cursor = self._connection.cursor()
+        if not db_exists:
+            self.init()
+
+    def init(self):
+        self._cursor.executescript(self.schema)
+        self._connection.commit()
+
+    def get_hosts(self):
+        hosts = []
+        hostnames = self._cursor.execute("SELECT name FROM hosts").fetchall()
+        hostnames = (host[0] for host in hostnames)
+        for hostname in hostnames:
+            if hostname is None:
+                continue
+            types = self.get_types(hostname)
+            hosts.append((hostname, types))
+        return hosts
+
+    def get_types(self, hostname):
+        sql = f"SELECT type FROM hosts_types WHERE host = '{hostname}'"
+        report_types = self._cursor.execute(sql).fetchall()
+        report_types = [report_type[0] for report_type in report_types]
+        return report_types
+
+    def get_latest_reports(self, hostname):
+        reports = []
+        host_types = self.get_types(hostname)
+        for host_type in host_types:
+            sql = f"SELECT rowid,raw_report  from reports WHERE type = '{host_type}' AND hostname= '{hostname}' ORDER BY rowid DESC LIMIT 1"
+            latest_report = self._cursor.execute(sql).fetchone()
+            reports.append(latest_report)
+        return reports
+
+    def add(self, report):
+        report_data = (report.hostname, report.type, report.date, report.raw_report)
+        self._cursor.execute("INSERT INTO reports VALUES (?, ?, ?, ?)", report_data)
+        report_id = self._cursor.lastrowid
+
+        self._cursor.execute(
+            "INSERT OR IGNORE INTO hosts VALUES (?)", (report.hostname,)
+        )
+        self._cursor.execute("INSERT OR IGNORE INTO types VALUES (?)", (report.type,))
+        self._cursor.execute(
+            "INSERT OR IGNORE INTO hosts_types VALUES (?,?)",
+            (report.hostname, report.type),
+        )
+
+        items = [
+            (
+                i.command,
+                i.status,
+                i.status_text,
+                i.additional_text,
+                i.raw_item,
+                report_id,
+            )
+            for i in report.items
+        ]
+        self._cursor.executemany("INSERT INTO items VALUES(?, ?, ?, ?, ?, ?)", items)
+
+        self._connection.commit()
+
+
+def adapt_date_iso(val):
+    """Adapt datetime.date to ISO 8601 date."""
+    return val.isoformat()
+
+
+def adapt_datetime_iso(val):
+    """Adapt datetime.datetime to timezone-naive ISO 8601 date."""
+    return val.replace(tzinfo=None).isoformat()
+
+
+def adapt_datetime_epoch(val):
+    """Adapt datetime.datetime to Unix timestamp."""
+    return int(val.timestamp())
+
+
+def convert_date(val):
+    """Convert ISO 8601 date to datetime.date object."""
+    return datetime.date.fromisoformat(val.decode())
+
+
+def convert_datetime(val):
+    """Convert ISO 8601 datetime to datetime.datetime object."""
+    return datetime.datetime.fromisoformat(val.decode())
+
+
+def convert_timestamp(val):
+    """Convert Unix epoch timestamp to datetime.datetime object."""
+    return datetime.datetime.fromtimestamp(int(val))
+
+
+sqlite3.register_converter("date", convert_date)
+sqlite3.register_converter("datetime", convert_datetime)
+sqlite3.register_converter("timestamp", convert_timestamp)
+sqlite3.register_adapter(datetime.date, adapt_date_iso)
+sqlite3.register_adapter(datetime.datetime, adapt_datetime_iso)
+sqlite3.register_adapter(datetime.datetime, adapt_datetime_epoch)

sysview_py/flock.py

@@ -0,0 +1,13 @@
+import fcntl
+from contextlib import contextmanager
+
+
+@contextmanager
+def lock_file(file_path):
+    f = open(file_path, 'w')
+    fcntl.flock(f.fileno(), fcntl.LOCK_EX)
+    try:
+        yield f
+    finally:
+        fcntl.flock(f.fileno(), fcntl.LOCK_UN)
+        f.close()

sysview_py/main.py

@@ -0,0 +1,27 @@
+from pathlib import Path
+import sys
+
+from .sysview import Sysview
+from .flock import lock_file
+
+LOCK_FILE=Path.home() / ".sysview.lock"
+
+
+def main():
+    with lock_file(LOCK_FILE):
+        sysview = Sysview()
+        db_path = Path.home() / ".sysview.db"
+        sysview.setup_db(db_path)
+        reports = []
+        if not sys.stdin.isatty():
+            reports = sysview.read_raw_reports_from_stdin()
+        if reports:
+            sysview.process_reports(reports)
+        sysview.read_hosts()
+        sysview.get_latest_reports()
+        sysview.update_html()
+        print("finished")
+
+
+if __name__ == "__main__":
+    main()

sysview_py/report.py

@@ -0,0 +1,185 @@
+import hashlib
+from datetime import datetime
+
+
+status_map = {
+        "UNKNOWN": 3,
+        "CRITICAL": 2,
+        "WARNING": 1,
+        "OK": 0
+}
+
+class Host:
+    def __init__(self, name, report_types=tuple(), reports=[]):
+        self.name = name
+        self.report_types = report_types
+        self.reports = reports
+
+    @property
+    def last_updated(self):
+        last_updated = None
+        for report in self.reports:
+            if last_updated is None:
+                last_updated = report.date
+            elif report.date > last_updated:
+                last_updated = report.date
+        return last_updated
+
+    @property
+    def all_items(self):
+        items = []
+        for report in self.reports:
+            for item in report.items:
+                item.report_type = report.type
+                item.date = report.date
+                item.host = self.name
+            items += report.items
+        items.sort(key=lambda item: item.status_code, reverse=True)
+        return items
+
+    @property
+    def status(self):
+        status = "UNKNOWN"
+        report_status = [report.status for report in self.reports]
+        if "OK" in report_status:
+            status = "OK"
+        if "UNKNOWN" in report_status:
+            status = "UNKNOWN"
+        if "WARNING" in report_status:
+            status = "WARNING"
+        if "CRITICAL" in report_status:
+            status = "CRITICAL"
+        return status
+
+    @property
+    def status_code(self):
+        return status_map[self.status]
+
+    def __repr__(self):
+        return f"Host(name={self.name}, status={self.status}, report_types={self.report_types})"
+
+
+class ReportItem:
+    valid_statuses = ("OK", "WARNING", "CRITICAL", "UNKNOWN")
+
+    def __init__(
+        self,
+        raw_item,
+        command=None,
+        status="UNKNOWN",
+        status_text=None,
+        additional_text=None,
+        date=None,
+        host=None,
+        report_type=None,
+        report_id=None
+    ):
+        self.raw_item = raw_item
+        self.command = command
+        self._status = status
+        self.status_text = status_text
+        self.additional_text = additional_text
+        self.date = date
+        self.report_type = report_type
+        self.report_id = report_id
+        self.host = host
+
+    def __repr__(self):
+        return f"ReportItem(command={self.command}, status={self.status})"
+
+    @property
+    def status(self):
+        age = datetime.now() - self.date
+        status = self._status
+        if age > 1:
+            status = "OUTDATED"
+        return status
+
+    @property
+    def status_code(self):
+        return status_map[self.status]
+
+    @property
+    def id(self):
+        return hashlib.sha256((f"{self.report_id}_{self.command}").encode('utf-8')).hexdigest()
+
+    def parse(self):
+        parsed_required_fields = False
+        self.command = None
+        self.status = "UNKNOWN"
+        self.status_text = None
+        self.additional_text = None
+        for line in self.raw_item.split("\n"):
+            if None not in (self.command, self.status, self.status_text):
+                parsed_required_fields = True
+            if line.startswith("Command:") and not parsed_required_fields:
+                self.command = ":".join(line.split(":")[1:]).lstrip()
+            elif (
+                line.split(":")[0] in self.valid_statuses and not parsed_required_fields
+            ):
+                self.status = line.split(":")[0]
+                self.status_text = ":".join(line.split(":")[1:])
+            elif parsed_required_fields:
+                if self.additional_text is None:
+                    self.additional_text = ""
+                self.additional_text += f"{line}\n"
+
+
+class Report:
+    def __init__(
+        self, raw_report, hostname=None, date=None, report_type=None, items=None, report_id=None
+    ):
+        self.raw_report = raw_report
+        self.hostname = hostname
+        self.date = date
+        self.type = report_type
+        self.items = items
+        self.report_id = report_id
+
+    def __repr__(self):
+        return f"Report(hostname={self.hostname}, type={self.type}, date={self.date}, status={self.status})"
+
+    @property
+    def status(self):
+        status = "UNKNOWN"
+        item_status = [item.status for item in self.items]
+        if "OK" in item_status:
+            status = "OK"
+        if "WARNING" in item_status:
+            status = "WARNING"
+        if "CRITICAL" in item_status:
+            status = "CRITICAL"
+        return status
+
+    @property
+    def status_code(self):
+        return status_map[self.status]
+
+    def parse(self):
+        item_pointer = 0
+        raw_report = []
+        self.items = []
+        raw_item = ""
+        for line in self.raw_report.split("\n"):
+            raw_report.append(line)
+            if line.startswith("Hostname:") and item_pointer == 0:
+                self.hostname = line.split(":")[1].strip()
+            elif line.startswith("Date:") and item_pointer == 0:
+                raw_date = line.replace("Date:", "").strip()
+                self.date = datetime.strptime(raw_date, "%a %b %d %X %Z %Y")
+            elif line.startswith("Type:") and item_pointer == 0:
+                self.type = "".join(line.split(":")[1].strip())
+            elif item_pointer > 0 and line != "---":
+                raw_item += f"{line}\n"
+            elif "---" == line:
+                if item_pointer > 0:
+                    item = ReportItem(raw_item, report_id=self.report_id)
+                    item.parse()
+                    self.items.append(item)
+                item_pointer = item_pointer + 1
+                raw_item = ""
+        item = ReportItem(raw_item, report_id=self.report_id)
+        item.parse()
+        self.items.append(item)
+        self.items.sort(key=lambda item: item.status_code, reverse=True)
+        self.raw_report = "\n".join(raw_report)