ironops 1.0.0__tar.gz

ironops-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Aziz Khemiri
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

ironops-1.0.0/PKG-INFO

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: ironops
+Version: 1.0.0
+Summary: DevOps CLI tool for remote server health monitoring over SSH
+Author: Aziz Khemiri
+License: MIT
+Project-URL: Homepage, https://github.com/AzizKhemiri/IronOps
+Project-URL: Repository, https://github.com/AzizKhemiri/IronOps
+Project-URL: Issues, https://github.com/AzizKhemiri/IronOps/issues
+Keywords: devops,ssh,monitoring,cli,server,health
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paramiko>=3.4.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# IronOps — DevOps CLI tool for remote server health monitoring
+<div align="center">
+  <img src="images/IronOps.png" width="700" alt="IronOps Logo">
+</div>
+
+### DevOps Project
+
+> A Python-based tool to check the health of multiple remote Linux servers over SSH — automatically collecting CPU, RAM, disk, and service metrics, then generating reports and sending alerts.
+
+---
+
+## Table of Contents
+- [What This Project Does](#-what-this-project-does)
+- [How It Works (Architecture)](#-how-it-works-architecture)
+- [Tools & Technologies](#-tools--technologies)
+- [Installation](#-installation)
+- [Configuration](#-configuration)
+- [Usage](#-usage)
+- [Example Output](#-example-output)
+- [Scheduling with Cron](#-scheduling-with-cron)
+- [Project Structure](#-project-structure)
+
+---
+
+## What This Project Does
+
+This tool connects to a list of remote Linux servers via **SSH**, runs health checks on each one, and:
+
+- Collects: **CPU usage**, **RAM usage**, **disk space**, **uptime**, **running services**
+- Generates a **JSON, readable report** for each run
+- Sends **email/Slack alerts** when a server exceeds thresholds (e.g., disk > 90%)
+- Can run **automatically on a schedule** using cron
+
+---
+
+## How It Works (Architecture) 
+<div align="center">
+  <img src="images/IronOps-Architecture.png" width="700" alt="Architecture Diagram">
+</div>
+---
+
+## Tools & Technologies
+
+| Tool | Why we use it | Learn more |
+|------|--------------|-----------|
+| **Python 3** | Main language | [python.org](https://python.org) |
+| **paramiko** | Python SSH library to connect to servers | [paramiko.org](https://paramiko.org) |
+| **PyYAML** | Read the servers config file (YAML format) | [pyyaml.org](https://pyyaml.org) |
+| **smtplib** | Built-in Python email sender for alerts | Python standard library |
+| **cron** | Linux scheduler to run the script automatically | `man cron` |
+| **JSON** | Report format | Built-in Python |
+
+### Why SSH?
+SSH (Secure Shell) is the industry-standard way to remotely access Linux servers. You connect using:
+- **Password** 
+- **SSH Key Pair**
+
+Our project supports **both methods**.
+
+---
+
+## Installation
+
+### Step 1 — Install Python 3
+
+```bash
+# Ubuntu/Debian
+sudo apt update && sudo apt install python3 python3-pip -y
+
+# macOS (using Homebrew)
+brew install python3
+```
+
+### Step 2 — Clone this project
+
+```bash
+git clone https://github.com/yourname/server-health-monitor.git
+cd server-health-monitor
+```
+
+### Step 3 — Install Python dependencies
+
+```bash
+pip3 install -r requirements.txt
+```
+
+This installs:
+- `paramiko` — SSH connections
+- `pyyaml` — reading YAML config files
+
+### Step 4 — Set up your SSH access
+
+**Using SSH keys (recommended for prod):**
+```bash
+# Generate an SSH key pair (if you don't have one already)
+ssh-keygen -t rsa -b 4096 -C "health-monitor"
+
+# Copy your public key to each remote server
+ssh-copy-id user@your-server-ip
+
+# Test it works
+ssh user@your-server-ip "echo connected successfully"
+```
+
+### Step 5 — Configure your servers
+
+Edit `config/servers.yaml` — see the [Configuration](#-configuration) section below.
+
+### Step 6 — Run this commande to track you server
+
+```bash
+python3 health_monitor.py
+```
+
+---
+
+## Configuration
+
+Edit `config/servers.yaml` to add your servers (e.g):
+
+```yaml
+# List of servers to monitor
+servers:
+  - name: "web-server-01"
+    host: "192.168.1.10"
+    port: 22
+    user: "ubuntu"
+    auth: "key"                        # "key" 
+    key_path: "~/.ssh/id_rsa"          # path to your private key
+```
+
+---
+
+## Usage
+
+### Basic run (check all servers once)
+```bash
+python3 health_monitor.py
+```
+
+### Check a single specific server
+```bash
+python3 health_monitor.py --server web-server-01
+```
+
+### Show verbose output
+```bash
+python3 health_monitor.py --verbose
+```
+
+### Save report to a custom location
+```bash
+python3 health_monitor.py --output /tmp/my-report.json
+```
+
+---
+
+## Example Terminak Output
+
+**python3 health_monitor.py --my-mac**
+<div align="center">
+  <img src="images/4-mac-demo.png" width="700" alt="Mac demo">
+</div>
+
+**python3 health_monitor.py**
+<div align="center">
+  <img src="images/1-demo.png" width="700" alt="Full health check demo">
+</div>
+
+**monitor.log**
+<div align="center">
+  <img src="images/3-demo.png" width="700" alt="Monitor log output">
+</div>
+
+**Demo fake data (test)**
+<div align="center">
+  <img src="images/2-demo.png" width="700" alt="Demo with fake data">
+</div>
+
+**JSON report (reports/health_20241115_143201.json):**
+```json
+{
+  "run_id": 1,
+  "timestamp": "2024-11-15T14:32:01Z",
+  "summary": {
+    "total": 3,
+    "healthy": 2,
+    "warning": 1,
+    "critical": 0,
+    "unreachable": 1
+  },
+  "servers": [
+    {
+      "name": "web-server-01",
+      "host": "192.168.1.10",
+      "status": "warning",
+      "metrics": {
+        "cpu_percent": 23.4,
+        "ram_percent": 61.2,
+        "disk_percent": 78.5,
+        "uptime": "14 days, 3 hours"
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Scheduling with Cron
+
+To run the health check automatically every 15 minutes:
+
+```bash
+# Open the cron editor
+crontab -e
+
+# Add this line (e.g: runs every 15 minutes)
+*/15 * * * * /usr/bin/python3 /path/to/server-health-monitor/health_monitor.py >> /var/log/health_monitor.log 2>&1
+```
+
+Cron schedule format: `minute  hour  day  month  weekday`
+```
+*/15 * * * *   → every 15 minutes
+0 * * * *      → every hour
+0 8 * * *      → every day at 8am
+0 8 * * 1      → every Monday at 8am
+```
+
+---
+
+## Project Structure
+
+```
+IronOps/
+│
+├── health_monitor.py       # Main entry point (run this)
+├── requirements.txt        # Python dependencies
+├── README.md               # This file
+│
+├── config/
+│   └── servers.yaml        # Your server list + settings
+│
+├── modules/
+│   ├── ssh_client.py       # Handles SSH connections
+│   ├── health_check.py     # Runs metric commands on servers to check
+│   ├── reporter.py         # Formats and saves reports
+│   └── alerter.py          # Sends email/Slack alerts
+│
+├── reports/                # Auto-generated JSON reports
+│   └── health_YYYYMMDD_HHMMSS.json
+│
+└── logs/                   # Run logs
+    └── monitor.log
+```
+
+---

ironops-1.0.0/README.md

@@ -0,0 +1,257 @@
+# IronOps — DevOps CLI tool for remote server health monitoring
+<div align="center">
+  <img src="images/IronOps.png" width="700" alt="IronOps Logo">
+</div>
+
+### DevOps Project
+
+> A Python-based tool to check the health of multiple remote Linux servers over SSH — automatically collecting CPU, RAM, disk, and service metrics, then generating reports and sending alerts.
+
+---
+
+## Table of Contents
+- [What This Project Does](#-what-this-project-does)
+- [How It Works (Architecture)](#-how-it-works-architecture)
+- [Tools & Technologies](#-tools--technologies)
+- [Installation](#-installation)
+- [Configuration](#-configuration)
+- [Usage](#-usage)
+- [Example Output](#-example-output)
+- [Scheduling with Cron](#-scheduling-with-cron)
+- [Project Structure](#-project-structure)
+
+---
+
+## What This Project Does
+
+This tool connects to a list of remote Linux servers via **SSH**, runs health checks on each one, and:
+
+- Collects: **CPU usage**, **RAM usage**, **disk space**, **uptime**, **running services**
+- Generates a **JSON, readable report** for each run
+- Sends **email/Slack alerts** when a server exceeds thresholds (e.g., disk > 90%)
+- Can run **automatically on a schedule** using cron
+
+---
+
+## How It Works (Architecture) 
+<div align="center">
+  <img src="images/IronOps-Architecture.png" width="700" alt="Architecture Diagram">
+</div>
+---
+
+## Tools & Technologies
+
+| Tool | Why we use it | Learn more |
+|------|--------------|-----------|
+| **Python 3** | Main language | [python.org](https://python.org) |
+| **paramiko** | Python SSH library to connect to servers | [paramiko.org](https://paramiko.org) |
+| **PyYAML** | Read the servers config file (YAML format) | [pyyaml.org](https://pyyaml.org) |
+| **smtplib** | Built-in Python email sender for alerts | Python standard library |
+| **cron** | Linux scheduler to run the script automatically | `man cron` |
+| **JSON** | Report format | Built-in Python |
+
+### Why SSH?
+SSH (Secure Shell) is the industry-standard way to remotely access Linux servers. You connect using:
+- **Password** 
+- **SSH Key Pair**
+
+Our project supports **both methods**.
+
+---
+
+## Installation
+
+### Step 1 — Install Python 3
+
+```bash
+# Ubuntu/Debian
+sudo apt update && sudo apt install python3 python3-pip -y
+
+# macOS (using Homebrew)
+brew install python3
+```
+
+### Step 2 — Clone this project
+
+```bash
+git clone https://github.com/yourname/server-health-monitor.git
+cd server-health-monitor
+```
+
+### Step 3 — Install Python dependencies
+
+```bash
+pip3 install -r requirements.txt
+```
+
+This installs:
+- `paramiko` — SSH connections
+- `pyyaml` — reading YAML config files
+
+### Step 4 — Set up your SSH access
+
+**Using SSH keys (recommended for prod):**
+```bash
+# Generate an SSH key pair (if you don't have one already)
+ssh-keygen -t rsa -b 4096 -C "health-monitor"
+
+# Copy your public key to each remote server
+ssh-copy-id user@your-server-ip
+
+# Test it works
+ssh user@your-server-ip "echo connected successfully"
+```
+
+### Step 5 — Configure your servers
+
+Edit `config/servers.yaml` — see the [Configuration](#-configuration) section below.
+
+### Step 6 — Run this commande to track you server
+
+```bash
+python3 health_monitor.py
+```
+
+---
+
+## Configuration
+
+Edit `config/servers.yaml` to add your servers (e.g):
+
+```yaml
+# List of servers to monitor
+servers:
+  - name: "web-server-01"
+    host: "192.168.1.10"
+    port: 22
+    user: "ubuntu"
+    auth: "key"                        # "key" 
+    key_path: "~/.ssh/id_rsa"          # path to your private key
+```
+
+---
+
+## Usage
+
+### Basic run (check all servers once)
+```bash
+python3 health_monitor.py
+```
+
+### Check a single specific server
+```bash
+python3 health_monitor.py --server web-server-01
+```
+
+### Show verbose output
+```bash
+python3 health_monitor.py --verbose
+```
+
+### Save report to a custom location
+```bash
+python3 health_monitor.py --output /tmp/my-report.json
+```
+
+---
+
+## Example Terminak Output
+
+**python3 health_monitor.py --my-mac**
+<div align="center">
+  <img src="images/4-mac-demo.png" width="700" alt="Mac demo">
+</div>
+
+**python3 health_monitor.py**
+<div align="center">
+  <img src="images/1-demo.png" width="700" alt="Full health check demo">
+</div>
+
+**monitor.log**
+<div align="center">
+  <img src="images/3-demo.png" width="700" alt="Monitor log output">
+</div>
+
+**Demo fake data (test)**
+<div align="center">
+  <img src="images/2-demo.png" width="700" alt="Demo with fake data">
+</div>
+
+**JSON report (reports/health_20241115_143201.json):**
+```json
+{
+  "run_id": 1,
+  "timestamp": "2024-11-15T14:32:01Z",
+  "summary": {
+    "total": 3,
+    "healthy": 2,
+    "warning": 1,
+    "critical": 0,
+    "unreachable": 1
+  },
+  "servers": [
+    {
+      "name": "web-server-01",
+      "host": "192.168.1.10",
+      "status": "warning",
+      "metrics": {
+        "cpu_percent": 23.4,
+        "ram_percent": 61.2,
+        "disk_percent": 78.5,
+        "uptime": "14 days, 3 hours"
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Scheduling with Cron
+
+To run the health check automatically every 15 minutes:
+
+```bash
+# Open the cron editor
+crontab -e
+
+# Add this line (e.g: runs every 15 minutes)
+*/15 * * * * /usr/bin/python3 /path/to/server-health-monitor/health_monitor.py >> /var/log/health_monitor.log 2>&1
+```
+
+Cron schedule format: `minute  hour  day  month  weekday`
+```
+*/15 * * * *   → every 15 minutes
+0 * * * *      → every hour
+0 8 * * *      → every day at 8am
+0 8 * * 1      → every Monday at 8am
+```
+
+---
+
+## Project Structure
+
+```
+IronOps/
+│
+├── health_monitor.py       # Main entry point (run this)
+├── requirements.txt        # Python dependencies
+├── README.md               # This file
+│
+├── config/
+│   └── servers.yaml        # Your server list + settings
+│
+├── modules/
+│   ├── ssh_client.py       # Handles SSH connections
+│   ├── health_check.py     # Runs metric commands on servers to check
+│   ├── reporter.py         # Formats and saves reports
+│   └── alerter.py          # Sends email/Slack alerts
+│
+├── reports/                # Auto-generated JSON reports
+│   └── health_YYYYMMDD_HHMMSS.json
+│
+└── logs/                   # Run logs
+    └── monitor.log
+```
+
+---

ironops-1.0.0/pyproject.toml

@@ -0,0 +1,60 @@
+# ================================================================
+# IronOps — pyproject.toml
+# ================================================================
+# This file tells Python HOW to package and install IronOps.
+#
+# Key concept — entry_points:
+#   This is the magic that creates the `ironops` command.
+#   When someone runs `pip install ironops`, pip reads this file
+#   and creates a small script in their PATH called `ironops`
+#   that calls our cli.main() function automatically.
+#
+# Standard: PEP 517/518 — the modern Python packaging standard.
+# ================================================================
+
+[build-system]
+requires      = ["setuptools>=68", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name        = "ironops"
+version     = "1.0.0"
+description = "DevOps CLI tool for remote server health monitoring over SSH"
+readme      = "README.md"
+license     = { text = "MIT" }
+requires-python = ">=3.8"
+
+authors = [
+  { name = "Aziz Khemiri" }
+]
+
+keywords = ["devops", "ssh", "monitoring", "cli", "server", "health"]
+
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+  "Topic :: System :: Monitoring",
+  "Topic :: System :: Systems Administration",
+  "Environment :: Console",
+]
+
+# Runtime dependencies
+dependencies = [
+  "paramiko>=3.4.0",
+  "PyYAML>=6.0",
+  "python-dotenv>=1.0.0",
+]
+
+# When user types `ironops --scan`, Python calls cli.main()
+[project.scripts]
+ironops = "ironops.cli:main"
+
+[project.urls]
+Homepage   = "https://github.com/AzizKhemiri/IronOps"
+Repository = "https://github.com/AzizKhemiri/IronOps"
+Issues     = "https://github.com/AzizKhemiri/IronOps/issues"
+
+# Package discovery
+[tool.setuptools.packages.find]
+where = ["src"]

ironops-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

ironops-1.0.0/src/ironops/__init__.py

@@ -0,0 +1,7 @@
+"""
+IronOps — DevOps CLI tool for remote server health monitoring.
+Author: Aziz Khemiri
+"""
+
+__version__ = "1.0.0"
+__author__  = "Aziz Khemiri"

ironops-1.0.0/src/ironops/__main__.py

@@ -0,0 +1,9 @@
+"""
+Allows running IronOps as:
+    python -m ironops --scan
+instead of just:
+    ironops --scan
+"""
+from ironops.cli import main
+
+main()

ironops-1.0.0/src/ironops/cli.py

@@ -0,0 +1,302 @@
+"""
+src/ironops/cli.py
+==================
+The CLI entry point for IronOps.
+
+This is the function that runs when a user types:
+    $ ironops --scan
+    $ ironops --status
+    $ ironops --monitor
+    $ ironops --help
+
+How it works:
+  pyproject.toml maps the `ironops` command to this file:
+      ironops = "ironops.cli:main"
+  pip creates a small wrapper script in PATH that calls main().
+
+Commands:
+  --scan     One-time health check of all servers
+  --status   Quick summary: how many servers are up/down
+  --monitor  Continuous loop — checks every N seconds
+  --version  Print IronOps version
+  --help     Show usage (built-in to argparse)
+"""
+
+import sys
+import time
+import argparse
+import os
+import yaml
+from dotenv import load_dotenv
+
+from ironops import __version__
+
+load_dotenv()
+
+
+# ANSI colors
+GREEN  = "\033[92m"
+YELLOW = "\033[93m"
+RED    = "\033[91m"
+CYAN   = "\033[96m"
+BOLD   = "\033[1m"
+RESET  = "\033[0m"
+
+
+def _banner():
+    print(f"""
+{BOLD}{CYAN}
+  ██╗██████╗  ██████╗ ███╗   ██╗ ██████╗ ██████╗ ███████╗
+  ██║██╔══██╗██╔═══██╗████╗  ██║██╔═══██╗██╔══██╗██╔════╝
+  ██║██████╔╝██║   ██║██╔██╗ ██║██║   ██║██████╔╝███████╗
+  ██║██╔══██╗██║   ██║██║╚██╗██║██║   ██║██╔═══╝ ╚════██║
+  ██║██║  ██║╚██████╔╝██║ ╚████║╚██████╔╝██║     ███████║
+  ╚═╝╚═╝  ╚═╝ ╚═════╝ ╚═╝  ╚═══╝ ╚═════╝ ╚═╝     ╚══════╝
+{RESET}  {CYAN}DevOps CLI tool for remote server health monitoring{RESET}
+  {YELLOW}v{__version__}  —  Author: Aziz Khemiri{RESET}
+""")
+
+
+def _get_core_path():
+    """
+    Locate the project root (where config/ and modules/ live).
+    Works whether installed via pip or run from source.
+    """
+    # When installed via pip, look for config next to the package
+    candidate = os.path.join(os.path.dirname(__file__), "..", "..", "..")
+    candidate = os.path.abspath(candidate)
+    if os.path.exists(os.path.join(candidate, "config", "servers.yaml")):
+        return candidate
+
+    # Fallback: current working directory
+    return os.getcwd()
+
+
+def _run_scan(args):
+    """
+    ironops --scan
+    One-time health check of all servers (or a specific one).
+    """
+    _banner()
+    root = _get_core_path()
+    sys.path.insert(0, root)
+
+    try:
+        # ✅ Load YAML directly, no env_loader needed
+        with open(os.path.join(root, "config", "servers.yaml"), "r") as f:
+            config = yaml.safe_load(f)
+        
+        from modules.health_check import check_server
+        from modules.reporter     import print_report, save_json_report
+        from modules.alerter      import send_alerts
+    except ImportError as e:
+        print(f"{RED}  Error: could not load IronOps modules: {e}{RESET}")
+        print(f"  Make sure you are running from the project directory.\n")
+        sys.exit(1)
+    except FileNotFoundError as e:
+        print(f"{RED}  Error: config file not found: {e}{RESET}")
+        print(f"  Run: {BOLD}ironops --init{RESET}\n")
+        sys.exit(1)
+
+    from datetime import datetime
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+    import logging
+
+    logging.basicConfig(level=logging.WARNING)
+
+    servers    = config.get("servers", [])
+    thresholds = config.get("thresholds", {})
+    alerts_cfg = config.get("alerts", {})
+
+    if not servers:
+        print(f"{RED}  Error: No servers defined in config/servers.yaml{RESET}\n")
+        sys.exit(1)
+
+    # Filter to one server if --server was passed
+    if args.server:
+        servers = [s for s in servers if s.get("name") == args.server]
+        if not servers:
+            print(f"{RED}  No server named '{args.server}' found.{RESET}\n")
+            sys.exit(1)
+
+    print(f"  {CYAN}Scanning {len(servers)} server(s)...{RESET}\n")
+    start = datetime.now()
+    results = []
+
+    with ThreadPoolExecutor(max_workers=min(5, len(servers))) as pool:
+        futures = {pool.submit(check_server, s, thresholds): s for s in servers}
+        for future in as_completed(futures):
+            try:
+                results.append(future.result())
+            except Exception as e:
+                s = futures[future]
+                results.append({
+                    "name": s.get("name", s["host"]), "host": s["host"],
+                    "status": "unreachable", "metrics": {}, "alerts": [],
+                    "error": str(e),
+                })
+
+    # Preserve config order
+    order = {s.get("name", s["host"]): i for i, s in enumerate(servers)}
+    results.sort(key=lambda r: order.get(r["name"], 999))
+
+    print_report(results, run_id=1, start_time=start)
+    save_json_report(results, run_id=1)
+    send_alerts(results, alerts_cfg)
+
+    has_critical = any(r["status"] in ("critical", "unreachable") for r in results)
+    sys.exit(1 if has_critical else 0)
+
+
+def _run_status(args):
+    """
+    ironops --status
+    Fast summary only — no full metric output, just up/down counts.
+    """
+    _banner()
+    root = _get_core_path()
+    sys.path.insert(0, root)
+
+    try:
+        # ✅ Load YAML directly
+        with open(os.path.join(root, "config", "servers.yaml"), "r") as f:
+            config = yaml.safe_load(f)
+        
+        from modules.ssh_client import SSHClient
+    except ImportError as e:
+        print(f"{RED}  Error: {e}{RESET}\n")
+        sys.exit(1)
+    except FileNotFoundError as e:
+        print(f"{RED}  Error: config file not found: {e}{RESET}\n")
+        sys.exit(1)
+
+    servers = config.get("servers", [])
+
+    if not servers:
+        print(f"{RED}  Error: No servers defined in config/servers.yaml{RESET}\n")
+        sys.exit(1)
+
+    print(f"  {CYAN}Checking connectivity for {len(servers)} server(s)...{RESET}\n")
+
+    up = down = 0
+    for s in servers:
+        name = s.get("name", s["host"])
+        client = SSHClient(s)
+        if client.connect():
+            print(f"  {GREEN}[UP]  {BOLD}{name}{RESET}  {s['host']}")
+            client.disconnect()
+            up += 1
+        else:
+            print(f"  {RED}[DOWN]{RESET}  {BOLD}{name}{RESET}  {s['host']}")
+            down += 1
+
+    print(f"\n  {BOLD}{'='*38}{RESET}")
+    print(f"  {GREEN}{up} UP{RESET}  |  {RED}{down} DOWN{RESET}  |  {up+down} total\n")
+
+
+def _run_monitor(args):
+    """
+    ironops --monitor
+    Continuous loop — scans every N seconds until Ctrl+C.
+    """
+    interval = args.interval or 60
+    _banner()
+    print(f"  {CYAN}Monitor mode — scanning every {interval}s  (Ctrl+C to stop){RESET}\n")
+
+    run = 0
+    try:
+        while True:
+            run += 1
+            print(f"  {YELLOW}── Run #{run}  {time.strftime('%H:%M:%S')} ──{RESET}")
+            args._mode = "scan_quiet"
+            _run_scan(args)
+            print(f"\n  {CYAN}Next scan in {interval}s...{RESET}")
+            time.sleep(interval)
+    except KeyboardInterrupt:
+        print(f"\n\n  {YELLOW}Monitor stopped.{RESET}\n")
+
+
+def main():
+    """
+    Entry point called by the `ironops` shell command.
+    Registered in pyproject.toml under [project.scripts].
+    """
+    parser = argparse.ArgumentParser(
+        prog="ironops",
+        description=f"{BOLD}IronOps{RESET} — DevOps CLI tool for remote server health monitoring",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog=f"""
+{BOLD}Examples:{RESET}
+  ironops --scan                    # check all servers once
+  ironops --scan --server web-01    # check one specific server
+  ironops --status                  # quick up/down summary
+  ironops --monitor                 # continuous scan (every 60s)
+  ironops --monitor --interval 30   # continuous scan (every 30s)
+
+{BOLD}Author:{RESET}  Aziz Khemiri
+{BOLD}Version:{RESET} {__version__}
+        """
+    )
+
+    # ── Mutually exclusive commands ──────────────────────────────────
+    group = parser.add_mutually_exclusive_group(required=True)
+
+    group.add_argument(
+        "--scan",
+        action="store_true",
+        help="Run a one-time health check on all servers"
+    )
+    group.add_argument(
+        "--status",
+        action="store_true",
+        help="Quick connectivity check — show which servers are up or down"
+    )
+    group.add_argument(
+        "--monitor",
+        action="store_true",
+        help="Continuous monitoring loop (checks every --interval seconds)"
+    )
+    group.add_argument(
+        "--version",
+        action="store_true",
+        help="Print IronOps version and exit"
+    )
+
+    # ── Optional flags ───────────────────────────────────────────────
+    parser.add_argument(
+        "--server",
+        metavar="NAME",
+        help="Target a single server by name (use with --scan)"
+    )
+    parser.add_argument(
+        "--interval",
+        type=int,
+        metavar="SECONDS",
+        default=60,
+        help="Scan interval in seconds for --monitor mode (default: 60)"
+    )
+    parser.add_argument(
+        "--config",
+        metavar="PATH",
+        default="config/servers.yaml",
+        help="Path to config file (default: config/servers.yaml)"
+    )
+
+    args = parser.parse_args()
+
+    # ── Route to the right action ────────────────────────────────────
+    if args.version:
+        print(f"ironops v{__version__}  —  by Aziz Khemiri")
+
+    elif args.scan:
+        _run_scan(args)
+
+    elif args.status:
+        _run_status(args)
+
+    elif args.monitor:
+        _run_monitor(args)
+
+
+if __name__ == "__main__":
+    main()

ironops-1.0.0/src/ironops.egg-info/PKG-INFO

@@ -0,0 +1,281 @@
+Metadata-Version: 2.4
+Name: ironops
+Version: 1.0.0
+Summary: DevOps CLI tool for remote server health monitoring over SSH
+Author: Aziz Khemiri
+License: MIT
+Project-URL: Homepage, https://github.com/AzizKhemiri/IronOps
+Project-URL: Repository, https://github.com/AzizKhemiri/IronOps
+Project-URL: Issues, https://github.com/AzizKhemiri/IronOps/issues
+Keywords: devops,ssh,monitoring,cli,server,health
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: System :: Monitoring
+Classifier: Topic :: System :: Systems Administration
+Classifier: Environment :: Console
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: paramiko>=3.4.0
+Requires-Dist: PyYAML>=6.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# IronOps — DevOps CLI tool for remote server health monitoring
+<div align="center">
+  <img src="images/IronOps.png" width="700" alt="IronOps Logo">
+</div>
+
+### DevOps Project
+
+> A Python-based tool to check the health of multiple remote Linux servers over SSH — automatically collecting CPU, RAM, disk, and service metrics, then generating reports and sending alerts.
+
+---
+
+## Table of Contents
+- [What This Project Does](#-what-this-project-does)
+- [How It Works (Architecture)](#-how-it-works-architecture)
+- [Tools & Technologies](#-tools--technologies)
+- [Installation](#-installation)
+- [Configuration](#-configuration)
+- [Usage](#-usage)
+- [Example Output](#-example-output)
+- [Scheduling with Cron](#-scheduling-with-cron)
+- [Project Structure](#-project-structure)
+
+---
+
+## What This Project Does
+
+This tool connects to a list of remote Linux servers via **SSH**, runs health checks on each one, and:
+
+- Collects: **CPU usage**, **RAM usage**, **disk space**, **uptime**, **running services**
+- Generates a **JSON, readable report** for each run
+- Sends **email/Slack alerts** when a server exceeds thresholds (e.g., disk > 90%)
+- Can run **automatically on a schedule** using cron
+
+---
+
+## How It Works (Architecture) 
+<div align="center">
+  <img src="images/IronOps-Architecture.png" width="700" alt="Architecture Diagram">
+</div>
+---
+
+## Tools & Technologies
+
+| Tool | Why we use it | Learn more |
+|------|--------------|-----------|
+| **Python 3** | Main language | [python.org](https://python.org) |
+| **paramiko** | Python SSH library to connect to servers | [paramiko.org](https://paramiko.org) |
+| **PyYAML** | Read the servers config file (YAML format) | [pyyaml.org](https://pyyaml.org) |
+| **smtplib** | Built-in Python email sender for alerts | Python standard library |
+| **cron** | Linux scheduler to run the script automatically | `man cron` |
+| **JSON** | Report format | Built-in Python |
+
+### Why SSH?
+SSH (Secure Shell) is the industry-standard way to remotely access Linux servers. You connect using:
+- **Password** 
+- **SSH Key Pair**
+
+Our project supports **both methods**.
+
+---
+
+## Installation
+
+### Step 1 — Install Python 3
+
+```bash
+# Ubuntu/Debian
+sudo apt update && sudo apt install python3 python3-pip -y
+
+# macOS (using Homebrew)
+brew install python3
+```
+
+### Step 2 — Clone this project
+
+```bash
+git clone https://github.com/yourname/server-health-monitor.git
+cd server-health-monitor
+```
+
+### Step 3 — Install Python dependencies
+
+```bash
+pip3 install -r requirements.txt
+```
+
+This installs:
+- `paramiko` — SSH connections
+- `pyyaml` — reading YAML config files
+
+### Step 4 — Set up your SSH access
+
+**Using SSH keys (recommended for prod):**
+```bash
+# Generate an SSH key pair (if you don't have one already)
+ssh-keygen -t rsa -b 4096 -C "health-monitor"
+
+# Copy your public key to each remote server
+ssh-copy-id user@your-server-ip
+
+# Test it works
+ssh user@your-server-ip "echo connected successfully"
+```
+
+### Step 5 — Configure your servers
+
+Edit `config/servers.yaml` — see the [Configuration](#-configuration) section below.
+
+### Step 6 — Run this commande to track you server
+
+```bash
+python3 health_monitor.py
+```
+
+---
+
+## Configuration
+
+Edit `config/servers.yaml` to add your servers (e.g):
+
+```yaml
+# List of servers to monitor
+servers:
+  - name: "web-server-01"
+    host: "192.168.1.10"
+    port: 22
+    user: "ubuntu"
+    auth: "key"                        # "key" 
+    key_path: "~/.ssh/id_rsa"          # path to your private key
+```
+
+---
+
+## Usage
+
+### Basic run (check all servers once)
+```bash
+python3 health_monitor.py
+```
+
+### Check a single specific server
+```bash
+python3 health_monitor.py --server web-server-01
+```
+
+### Show verbose output
+```bash
+python3 health_monitor.py --verbose
+```
+
+### Save report to a custom location
+```bash
+python3 health_monitor.py --output /tmp/my-report.json
+```
+
+---
+
+## Example Terminak Output
+
+**python3 health_monitor.py --my-mac**
+<div align="center">
+  <img src="images/4-mac-demo.png" width="700" alt="Mac demo">
+</div>
+
+**python3 health_monitor.py**
+<div align="center">
+  <img src="images/1-demo.png" width="700" alt="Full health check demo">
+</div>
+
+**monitor.log**
+<div align="center">
+  <img src="images/3-demo.png" width="700" alt="Monitor log output">
+</div>
+
+**Demo fake data (test)**
+<div align="center">
+  <img src="images/2-demo.png" width="700" alt="Demo with fake data">
+</div>
+
+**JSON report (reports/health_20241115_143201.json):**
+```json
+{
+  "run_id": 1,
+  "timestamp": "2024-11-15T14:32:01Z",
+  "summary": {
+    "total": 3,
+    "healthy": 2,
+    "warning": 1,
+    "critical": 0,
+    "unreachable": 1
+  },
+  "servers": [
+    {
+      "name": "web-server-01",
+      "host": "192.168.1.10",
+      "status": "warning",
+      "metrics": {
+        "cpu_percent": 23.4,
+        "ram_percent": 61.2,
+        "disk_percent": 78.5,
+        "uptime": "14 days, 3 hours"
+      }
+    }
+  ]
+}
+```
+
+---
+
+## Scheduling with Cron
+
+To run the health check automatically every 15 minutes:
+
+```bash
+# Open the cron editor
+crontab -e
+
+# Add this line (e.g: runs every 15 minutes)
+*/15 * * * * /usr/bin/python3 /path/to/server-health-monitor/health_monitor.py >> /var/log/health_monitor.log 2>&1
+```
+
+Cron schedule format: `minute  hour  day  month  weekday`
+```
+*/15 * * * *   → every 15 minutes
+0 * * * *      → every hour
+0 8 * * *      → every day at 8am
+0 8 * * 1      → every Monday at 8am
+```
+
+---
+
+## Project Structure
+
+```
+IronOps/
+│
+├── health_monitor.py       # Main entry point (run this)
+├── requirements.txt        # Python dependencies
+├── README.md               # This file
+│
+├── config/
+│   └── servers.yaml        # Your server list + settings
+│
+├── modules/
+│   ├── ssh_client.py       # Handles SSH connections
+│   ├── health_check.py     # Runs metric commands on servers to check
+│   ├── reporter.py         # Formats and saves reports
+│   └── alerter.py          # Sends email/Slack alerts
+│
+├── reports/                # Auto-generated JSON reports
+│   └── health_YYYYMMDD_HHMMSS.json
+│
+└── logs/                   # Run logs
+    └── monitor.log
+```
+
+---

ironops-1.0.0/src/ironops.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+LICENSE
+README.md
+pyproject.toml
+src/ironops/__init__.py
+src/ironops/__main__.py
+src/ironops/cli.py
+src/ironops.egg-info/PKG-INFO
+src/ironops.egg-info/SOURCES.txt
+src/ironops.egg-info/dependency_links.txt
+src/ironops.egg-info/entry_points.txt
+src/ironops.egg-info/requires.txt
+src/ironops.egg-info/top_level.txt

ironops-1.0.0/src/ironops.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

ironops-1.0.0/src/ironops.egg-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ironops = ironops.cli:main

ironops-1.0.0/src/ironops.egg-info/requires.txt

@@ -0,0 +1,3 @@
+paramiko>=3.4.0
+PyYAML>=6.0
+python-dotenv>=1.0.0

ironops-1.0.0/src/ironops.egg-info/top_level.txt

@@ -0,0 +1 @@
+ironops