Merge pull request #2 from SystemGuard-official/features/caching

Features/caching

Author: codeperfectplus

README.md

@@ -43,7 +43,7 @@ It will install the SystemGuard app and its dependencies in the crontab and it w
 ```bash
 # install miniconda3 if not installed already
 wget https://raw.githubusercontent.com/codeperfectplus/HackScripts/main/setup/install_miniconda.sh
-chmod +x install_miniconda.sh && ./install_miniconda.sh
+chmod +x install_miniconda.sh && sudo ./install_miniconda.sh
 ```
 
 ## Features 🚀
@@ -84,6 +84,12 @@ chmod +x install_miniconda.sh && ./install_miniconda.sh
 
 A Docker image has not been created for this project because it requires access to the host machine in order to retrieve server stats. Therefore, it is not possible to obtain server stats from within a Docker container.
 
+## Upcoming Features 📅
+
+- Threshold notifications
+- Customizable dashboards
+- Plugin support to make SystemGuard even more powerful.
+
 ## Acknowledgments
 
 | Project        | License             | Repository                                      |

src/models.py

@@ -22,9 +22,36 @@ def __repr__(self):
 class DashboardSettings(db.Model):
     __tablename__ = "DashboardSettings"
     id = db.Column(db.Integer, primary_key=True)
+    
+    # speedtest setting
     speedtest_cooldown = db.Column(db.Integer, default=1)
     number_of_speedtests = db.Column(db.Integer, default=1)
+
+    # general settings
     timezone = db.Column(db.String(50), default="Asia/Kolkata")
+    enable_cache = db.Column(db.Boolean, default=True)
+
+    # page enable/disable
+    is_cpu_info_enabled = db.Column(db.Boolean, default=True)
+    is_memory_info_enabled = db.Column(db.Boolean, default=True)
+    is_disk_info_enabled = db.Column(db.Boolean, default=True)
+    is_network_info_enabled = db.Column(db.Boolean, default=True)
+    is_process_info_enabled = db.Column(db.Boolean, default=False)
+
+
+    # card enable/disable
+    is_user_card_enabled = db.Column(db.Boolean, default=True)
+    is_server_card_enabled = db.Column(db.Boolean, default=True)
+    is_battery_card_enabled = db.Column(db.Boolean, default=True)
+    is_cpu_core_card_enabled = db.Column(db.Boolean, default=True)
+    is_cpu_usage_card_enabled = db.Column(db.Boolean, default=True)
+    is_cpu_temp_card_enabled = db.Column(db.Boolean, default=True)
+    is_dashboard_memory_card_enabled = db.Column(db.Boolean, default=True)
+    is_memory_usage_card_enabled = db.Column(db.Boolean, default=True)
+    is_disk_usage_card_enabled = db.Column(db.Boolean, default=True)
+    is_system_uptime_card_enabled = db.Column(db.Boolean, default=True)
+    is_network_statistic_card_enabled = db.Column(db.Boolean, default=True)
+    is_speedtest_enabled = db.Column(db.Boolean, default=False)
 
     def __repr__(self):
         return f"<DashboardSettings {self.speedtest_cooldown}, {self.timezone}, {self.number_of_speedtests}>"
@@ -76,4 +103,10 @@ class User(db.Model, UserMixin):
         hashed_password = generate_password_hash('adminpassword')
         admin_user = User(username='admin', password=hashed_password, user_level='admin')
         db.session.add(admin_user)
-        db.session.commit()
+        db.session.commit()
+
+# ibject for all templates
+@app.context_processor
+def inject_settings():
+    settings = DashboardSettings.query.first()
+    return dict(settings=settings)

src/routes/cpu_info.py

@@ -2,15 +2,21 @@
 from flask import render_template, blueprints
 
 from src.config import app
-from src.utils import get_cpu_core_count, get_cpu_frequency, cpu_usage_percent, get_cpu_temp
+from src.utils import get_cpu_core_count, get_cpu_frequency, cpu_usage_percent, get_cpu_temp, get_cached_value
+from src.models import DashboardSettings
 
 cpu_info_bp = blueprints.Blueprint("cpu_usage", __name__)
 
 @app.route("/cpu_usage")
 def cpu_usage():
+    settings = DashboardSettings.query.first()
+    if not settings.is_cpu_info_enabled:
+        return render_template("error/404.html")
+    
     current_temp, high_temp, critical_temp = get_cpu_temp()
+    cpu_core = get_cached_value("cpu_core", get_cpu_core_count)
     system_info = {
-        "cpu_core": get_cpu_core_count(),
+        "cpu_core": cpu_core,
         "cpu_frequency": get_cpu_frequency(),
         "cpu_percent": cpu_usage_percent(),
         "current_temp": current_temp,

src/routes/disk_info.py

@@ -3,16 +3,22 @@
 from flask import render_template, blueprints
 
 from src.config import app
+from src.utils import get_cached_value, get_disk_free, get_disk_total, get_disk_used, get_disk_usage_percent
+from src.models import DashboardSettings
 
 disk_info_bp = blueprints.Blueprint("disk_usage", __name__)
 
 @app.route("/disk_usage")
 def disk_usage():
+    settings = DashboardSettings.query.first()
+    if not settings.is_disk_info_enabled:
+        return render_template("error/404.html")
+    disk_total = get_cached_value("disk_total", get_disk_total)
     system_info = {
-        "disk_usage": psutil.disk_usage("/").percent,
-        "disk_total": round(psutil.disk_usage("/").total / (1024**3), 2),  # In GB
-        "disk_used": round(psutil.disk_usage("/").used / (1024**3), 2),  # In GB
-        "disk_free": round(psutil.disk_usage("/").free / (1024**3), 2),  # In GB
+        "disk_usage": get_disk_usage_percent(),
+        "disk_total": disk_total,
+        "disk_used": get_disk_used(),
+        "disk_free": get_disk_free(),
     }
     return render_template("disk_info.html", system_info=system_info)
 

src/routes/homepage.py

@@ -1,5 +1,5 @@
 import datetime
-from flask import render_template, blueprints
+from flask import render_template, blueprints, session
 
 from src.config import app
 from src.models import SpeedTestResult, DashboardSettings, SystemInfo

src/routes/memory_info.py

@@ -1,23 +1,26 @@
 import psutil
 from flask import render_template, blueprints
 
-from src.utils import swap_memory_info
-
 from src.config import app
+from src.utils import get_cached_value, get_memory_percent, get_memory_available, get_memory_used, get_swap_memory_info
+from src.models import DashboardSettings
 
 memory_info_bp = blueprints.Blueprint("memory_usage", __name__)
 
+
 @app.route("/memory_usage")
 def memory_usage():
-    total_swap, used_swap, free_swap = swap_memory_info()
+    settings = DashboardSettings.query.first()
+    if not settings.is_memory_info_enabled:
+        return render_template("error/404.html")
+    memory_available = get_cached_value("memory_available", get_memory_available) 
     system_info = {
-        "memory_percent": psutil.virtual_memory().percent,
-        "memory_available": round(
-            psutil.virtual_memory().available / (1024**3), 2
-        ),  # In GB
-        "memory_used": round(psutil.virtual_memory().used / (1024**3), 2),  # In GB,
-        "total_swap": round(total_swap / (1024**3), 2),  # In GB
-        "used_swap": round(used_swap / (1024**3), 2),  # In GB
-        "free_swap": round(free_swap / (1024**3), 2),  # In GB
+        "memory_percent": get_memory_percent(),
+        "memory_available": memory_available,
+        "memory_used": get_memory_used(),
     }
+
+    swap_info = get_swap_memory_info()
+    system_info.update(swap_info)
+
     return render_template("memory_info.html", system_info=system_info)

src/routes/network_info.py

@@ -3,10 +3,15 @@
 
 from src.config import app
 from src.utils import get_established_connections
+from src.models import DashboardSettings
+
 network_info_bp = blueprints.Blueprint("network_stats", __name__)
 
 @app.route("/network_stats")
 def network_stats():
+    settings = DashboardSettings.query.first()
+    if not settings.is_network_info_enabled:
+        return render_template("error/404.html")
     net_io = psutil.net_io_counters()
     ipv4_ip, ipv6_ip = get_established_connections()
     system_info = {

src/routes/process.py

@@ -3,12 +3,16 @@
 from flask_login import login_required, current_user
 from src.config import app
 from src.utils import get_top_processes
+from src.models import DashboardSettings
 
 process_bp = blueprints.Blueprint("process", __name__)
 
 @app.route("/process", methods=["GET", "POST"])
 @login_required
 def process():
+    settings = DashboardSettings.query.first()
+    if not settings.is_process_info_enabled:
+        return render_template("error/404.html")
     if current_user.user_level != "admin":
         flash("You do not have permission to view this page.", "danger")
         return redirect(url_for("dashboard"))

src/routes/settings.py

@@ -1,20 +1,42 @@
 from flask import render_template, request, flash, blueprints
-
 from src.config import app, db
 from src.models import DashboardSettings
 
 settings_bp = blueprints.Blueprint("settings", __name__)
 
 @app.route("/settings", methods=["GET", "POST"])
 def settings():
-    # Fetch the settings from the database and update them
+    # Fetch the settings from the database
     settings = DashboardSettings.query.first()
     if settings:
         if request.method == "POST":
+            # Update settings from the form inputs
             settings.speedtest_cooldown = int(request.form["speedtest_cooldown"])
             settings.number_of_speedtests = int(request.form["number_of_speedtests"])
             settings.timezone = request.form["timezone"]
+            settings.is_cpu_info_enabled = "is_cpu_info_enabled" in request.form
+            settings.is_memory_info_enabled = "is_memory_info_enabled" in request.form
+            settings.is_disk_info_enabled = "is_disk_info_enabled" in request.form
+            settings.is_network_info_enabled = "is_network_info_enabled" in request.form
+            settings.is_process_info_enabled = "is_process_info_enabled" in request.form
+            settings.enable_cache = "enable_cache" in request.form
+
+            # <!-- is_user_card_enabled -->
+            settings.is_user_card_enabled = "is_user_card_enabled" in request.form
+            settings.is_server_card_enabled = "is_server_card_enabled" in request.form
+            settings.is_battery_card_enabled = "is_battery_card_enabled" in request.form
+            settings.is_cpu_core_card_enabled = "is_cpu_core_card_enabled" in request.form
+            settings.is_cpu_usage_card_enabled = "is_cpu_usage_card_enabled" in request.form
+            settings.is_cpu_temp_card_enabled = "is_cpu_temp_card_enabled" in request.form
+            settings.is_dashboard_memory_card_enabled = "is_dashboard_memory_card_enabled" in request.form
+            settings.is_memory_usage_card_enabled = "is_memory_usage_card_enabled" in request.form
+            settings.is_disk_usage_card_enabled = "is_disk_usage_card_enabled" in request.form
+            settings.is_system_uptime_card_enabled = "is_system_uptime_card_enabled" in request.form
+            settings.is_network_statistic_card_enabled = "is_network_statistic_card_enabled" in request.form
+            settings.is_speedtest_enabled = "is_speedtest_enabled" in request.form
+
+            # Commit the changes to the database
             db.session.commit()
             flash("Settings updated successfully!", "success")
+        
         return render_template("settings.html", settings=settings)
-

src/scripts/locustfile.py

@@ -1,3 +1,5 @@
+import os
+
 from locust import HttpUser, TaskSet, task, between
 from locust.exception import StopUser
 
@@ -44,5 +46,4 @@ class WebsiteUser(HttpUser):
     wait_time = between(1, 5)  # Time to wait between tasks
 
 if __name__ == "__main__":
-    import os
-    # os.system("locust -f locustfile.py --host=http://localhost:5000")
+    os.system("locust -f locustfile.py --host=http://localhost:5000")