open-aws-scanner 0.1.0__py3-none-any.whl

open_aws_scanner/__init__.py

@@ -0,0 +1,3 @@
+"""Open AWS Scanner - Find unused AWS resources costing you money."""
+
+__version__ = "0.1.0"

open_aws_scanner/api.py

@@ -0,0 +1,237 @@
+"""
+Open AWS Scanner API
+Simple, no-auth AWS cost waste scanner. Configure via config.env and go.
+"""
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from apscheduler.schedulers.background import BackgroundScheduler
+from .scanner import run_scan
+from .database import SessionLocal, ScanResult, ScanRun, init_db
+from slowapi import Limiter, _rate_limit_exceeded_handler
+from slowapi.util import get_remote_address
+from slowapi.errors import RateLimitExceeded
+from dotenv import load_dotenv
+from datetime import datetime, timezone
+import os
+
+# Load config.env from current working directory if it exists
+_config_path = os.path.join(os.getcwd(), "config.env")
+if os.path.exists(_config_path):
+    load_dotenv(_config_path)
+
+# --- Config ---
+SCAN_INTERVAL_HOURS = int(os.getenv("SCAN_INTERVAL_HOURS", "6"))
+HOST = os.getenv("HOST", "0.0.0.0")
+PORT = int(os.getenv("PORT", "8000"))
+
+limiter = Limiter(key_func=get_remote_address)
+app = FastAPI(
+    title="Open AWS Scanner",
+    version="1.0.0",
+    description="Simple AWS waste detection — no admin, no auth, just results.",
+)
+app.state.limiter = limiter
+app.add_exception_handler(RateLimitExceeded, _rate_limit_exceeded_handler)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+scheduler = BackgroundScheduler()
+
+
+# --- Startup ---
+
+@app.on_event("startup")
+def startup_event():
+    init_db()
+    # Schedule recurring scans
+    scheduler.add_job(
+        func=run_scan,
+        trigger="interval",
+        hours=SCAN_INTERVAL_HOURS,
+        id="scheduled_scan",
+        replace_existing=True,
+    )
+    scheduler.start()
+    print(f"[OPEN-SCANNER] Running. Scans every {SCAN_INTERVAL_HOURS}h.")
+
+
+# --- Health ---
+
+@app.get("/health")
+def health_check():
+    return {"status": "online", "scan_interval_hours": SCAN_INTERVAL_HOURS}
+
+
+# --- Dashboard ---
+
+@app.get("/", include_in_schema=False)
+def dashboard():
+    db = SessionLocal()
+    results = db.query(ScanResult).all()
+    runs = db.query(ScanRun).order_by(ScanRun.started_at.desc()).limit(1).all()
+    db.close()
+
+    total = len(results)
+    total_savings = sum(r.estimated_monthly_savings or 0 for r in results)
+    open_count = sum(1 for r in results if (r.status or "open") == "open")
+    fixed_count = sum(1 for r in results if r.status == "fixed")
+    last_scan = runs[0].completed_at.isoformat() if runs and runs[0].completed_at else "Never"
+
+    return {
+        "app": "Open AWS Scanner",
+        "status": "online",
+        "total_findings": total,
+        "open": open_count,
+        "fixed": fixed_count,
+        "potential_savings_per_month": f"${total_savings:.2f}",
+        "last_scan": last_scan,
+        "endpoints": {
+            "POST /scan": "Trigger a scan",
+            "GET /findings": "List findings (?status=open&resource_type=EC2_Instance)",
+            "PUT /findings/{id}/status?status=fixed": "Update finding status",
+            "GET /summary": "Savings breakdown by status",
+            "GET /scans": "Scan run history",
+            "GET /docs": "Swagger UI",
+        },
+    }
+
+
+# --- Trigger Scan ---
+
+@app.post("/scan")
+def trigger_scan():
+    """Trigger a scan now."""
+    from threading import Thread
+    Thread(target=run_scan).start()
+    return {"status": "scan_triggered"}
+
+
+# --- Get Findings ---
+
+@app.get("/findings")
+def get_findings(status: str = None, resource_type: str = None):
+    """Get all findings, optionally filtered by status or resource_type."""
+    db = SessionLocal()
+    query = db.query(ScanResult).order_by(ScanResult.scanned_at.desc())
+    if status:
+        query = query.filter(ScanResult.status == status)
+    if resource_type:
+        query = query.filter(ScanResult.resource_type == resource_type)
+    results = query.all()
+    db.close()
+
+    return [
+        {
+            "id": r.id,
+            "resource_id": r.resource_id,
+            "resource_name": r.resource_name,
+            "resource_type": r.resource_type,
+            "reason": r.reason,
+            "estimated_monthly_savings": r.estimated_monthly_savings,
+            "scanned_at": r.scanned_at.isoformat() if r.scanned_at else None,
+            "tags": r.tags,
+            "cpu_avg_percent": r.cpu_avg_percent,
+            "memory_avg_percent": r.memory_avg_percent,
+            "network_in_bytes": r.network_in_bytes,
+            "network_out_bytes": r.network_out_bytes,
+            "status": r.status or "open",
+            "status_changed_at": r.status_changed_at.isoformat() if r.status_changed_at else None,
+            "first_seen_at": r.first_seen_at.isoformat() if r.first_seen_at else None,
+            "region": r.region,
+        }
+        for r in results
+    ]
+
+
+# --- Update Finding Status ---
+
+@app.put("/findings/{finding_id}/status")
+def update_finding_status(finding_id: int, status: str):
+    """Update finding status: open, fixed, dismissed, in_progress"""
+    if status not in ("open", "fixed", "dismissed", "in_progress"):
+        raise HTTPException(status_code=400, detail="Status must be: open, fixed, dismissed, in_progress")
+    db = SessionLocal()
+    finding = db.query(ScanResult).filter(ScanResult.id == finding_id).first()
+    if not finding:
+        db.close()
+        raise HTTPException(status_code=404, detail="Finding not found")
+    finding.status = status
+    finding.status_changed_at = datetime.now(timezone.utc)
+    db.commit()
+    db.close()
+    return {"id": finding_id, "status": status}
+
+
+# --- Summary ---
+
+@app.get("/summary")
+def findings_summary():
+    """Summary of findings by status with savings totals."""
+    db = SessionLocal()
+    results = db.query(ScanResult).all()
+    db.close()
+
+    open_findings = [r for r in results if (r.status or "open") == "open"]
+    fixed_findings = [r for r in results if r.status == "fixed"]
+    dismissed_findings = [r for r in results if r.status == "dismissed"]
+    in_progress = [r for r in results if r.status == "in_progress"]
+
+    return {
+        "total_findings": len(results),
+        "total_potential_savings": sum(r.estimated_monthly_savings or 0 for r in results),
+        "open": {
+            "count": len(open_findings),
+            "savings": sum(r.estimated_monthly_savings or 0 for r in open_findings),
+        },
+        "fixed": {
+            "count": len(fixed_findings),
+            "savings_realized": sum(r.estimated_monthly_savings or 0 for r in fixed_findings),
+        },
+        "dismissed": {
+            "count": len(dismissed_findings),
+            "savings": sum(r.estimated_monthly_savings or 0 for r in dismissed_findings),
+        },
+        "in_progress": {
+            "count": len(in_progress),
+            "savings": sum(r.estimated_monthly_savings or 0 for r in in_progress),
+        },
+    }
+
+
+# --- Scan History ---
+
+@app.get("/scans")
+def get_scan_history():
+    """Get recent scan runs."""
+    db = SessionLocal()
+    runs = db.query(ScanRun).order_by(ScanRun.started_at.desc()).limit(50).all()
+    db.close()
+    return [
+        {
+            "id": r.id,
+            "status": r.status,
+            "findings_count": r.findings_count,
+            "errors": r.errors,
+            "started_at": r.started_at.isoformat() if r.started_at else None,
+            "completed_at": r.completed_at.isoformat() if r.completed_at else None,
+        }
+        for r in runs
+    ]
+
+
+# --- Run ---
+
+def serve():
+    """Start the API server."""
+    import uvicorn
+    uvicorn.run("open_aws_scanner.api:app", host=HOST, port=PORT, reload=False)
+
+
+if __name__ == "__main__":
+    serve()

open_aws_scanner/cli.py

@@ -0,0 +1,163 @@
+"""CLI entry point for open-aws-scanner."""
+import argparse
+import os
+import sys
+import json
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        prog="open-aws-scanner",
+        description="Find unused AWS resources costing you money.",
+    )
+    subparsers = parser.add_subparsers(dest="command")
+
+    # serve - start the API server
+    serve_parser = subparsers.add_parser("serve", help="Start the API server")
+    serve_parser.add_argument("--host", default="0.0.0.0", help="Host to bind (default: 0.0.0.0)")
+    serve_parser.add_argument("--port", type=int, default=8000, help="Port to bind (default: 8000)")
+    serve_parser.add_argument("--config", default="config.env", help="Path to config.env file")
+
+    # scan - run a one-shot scan (no server)
+    scan_parser = subparsers.add_parser("scan", help="Run a one-shot scan and print results")
+    scan_parser.add_argument("--regions", help="Comma-separated AWS regions (overrides config)")
+    scan_parser.add_argument("--role-arn", help="AWS role ARN to assume (overrides config)")
+    scan_parser.add_argument("--output", choices=["json", "table"], default="table", help="Output format")
+    scan_parser.add_argument("--config", default="config.env", help="Path to config.env file")
+
+    # init - create a config.env template
+    subparsers.add_parser("init", help="Create a config.env template in the current directory")
+
+    args = parser.parse_args()
+
+    if args.command is None:
+        parser.print_help()
+        sys.exit(0)
+
+    if args.command == "init":
+        _cmd_init()
+    elif args.command == "serve":
+        _cmd_serve(args)
+    elif args.command == "scan":
+        _cmd_scan(args)
+
+
+def _cmd_init():
+    """Create a config.env template."""
+    config_path = os.path.join(os.getcwd(), "config.env")
+    if os.path.exists(config_path):
+        print(f"config.env already exists at {config_path}")
+        sys.exit(1)
+
+    template = """# Open AWS Scanner Configuration
+
+# AWS Credentials (use IAM role ARN for cross-account scanning, or leave blank for local credentials)
+AWS_ROLE_ARN=
+AWS_EXTERNAL_ID=
+AWS_REGIONS=us-east-1
+
+# Optional: explicit credentials (prefer IAM roles or environment/profile instead)
+# AWS_ACCESS_KEY_ID=
+# AWS_SECRET_ACCESS_KEY=
+
+# Scanner settings
+SCAN_INTERVAL_HOURS=6
+STAGE_MODE=false
+
+# Server
+HOST=0.0.0.0
+PORT=8000
+"""
+    with open(config_path, "w") as f:
+        f.write(template)
+    print(f"Created {config_path}")
+    print("Edit it with your AWS configuration, then run: open-aws-scanner serve")
+
+
+def _cmd_serve(args):
+    """Start the API server."""
+    from dotenv import load_dotenv
+
+    config_path = os.path.abspath(args.config)
+    if os.path.exists(config_path):
+        load_dotenv(config_path)
+
+    os.environ.setdefault("HOST", args.host)
+    os.environ.setdefault("PORT", str(args.port))
+
+    from .database import init_db
+    init_db()
+
+    import uvicorn
+    uvicorn.run(
+        "open_aws_scanner.api:app",
+        host=args.host,
+        port=args.port,
+        reload=False,
+    )
+
+
+def _cmd_scan(args):
+    """Run a one-shot scan without starting the server."""
+    from dotenv import load_dotenv
+
+    config_path = os.path.abspath(args.config)
+    if os.path.exists(config_path):
+        load_dotenv(config_path)
+
+    # CLI overrides
+    if args.regions:
+        os.environ["AWS_REGIONS"] = args.regions
+    if args.role_arn:
+        os.environ["AWS_ROLE_ARN"] = args.role_arn
+
+    from .database import init_db
+    init_db()
+
+    # Redirect scanner logs to stderr so --output json works cleanly
+    from .scanner import run_scan
+    old_stdout = sys.stdout
+    sys.stdout = sys.stderr
+    findings = run_scan()
+    sys.stdout = old_stdout
+
+    if not findings:
+        print("\nNo waste found! Your AWS account looks clean.")
+        return
+
+    if args.output == "json":
+        print(json.dumps(findings, indent=2, default=str))
+    else:
+        _print_table(findings)
+
+
+def _print_table(findings):
+    """Print findings as a formatted table."""
+    total_savings = sum(f.get("estimated_monthly_savings") or 0 for f in findings)
+
+    print(f"\n{'='*80}")
+    print(f" Open AWS Scanner — {len(findings)} issues found | ${total_savings:.2f}/mo potential savings")
+    print(f"{'='*80}\n")
+
+    # Group by resource type
+    by_type = {}
+    for f in findings:
+        rtype = f["resource_type"]
+        by_type.setdefault(rtype, []).append(f)
+
+    for rtype, items in sorted(by_type.items()):
+        type_savings = sum(i.get("estimated_monthly_savings") or 0 for i in items)
+        print(f"  {rtype} ({len(items)} found, ${type_savings:.2f}/mo)")
+        for item in items:
+            savings = f"  ${item['estimated_monthly_savings']:.2f}/mo" if item.get("estimated_monthly_savings") else ""
+            region = f"  [{item['region']}]" if item.get("region") else ""
+            print(f"    • {item['resource_name']}: {item['reason']}{savings}{region}")
+        print()
+
+    print(f"{'─'*80}")
+    print(f"  Total potential savings: ${total_savings:.2f}/month")
+    print()
+
+
+if __name__ == "__main__":
+    main()

open_aws_scanner/database.py

@@ -0,0 +1,46 @@
+from sqlalchemy import create_engine, Column, Integer, String, Text, Float, DateTime
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+import datetime
+import os
+
+DATABASE_URL = os.getenv("DATABASE_URL", "sqlite:///./scanner.db")
+
+engine = create_engine(DATABASE_URL, connect_args={"check_same_thread": False} if "sqlite" in DATABASE_URL else {})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, expire_on_commit=False, bind=engine)
+Base = declarative_base()
+
+
+class ScanResult(Base):
+    __tablename__ = "scan_results"
+    id = Column(Integer, primary_key=True, index=True)
+    scan_run_id = Column(Integer)
+    resource_id = Column(String)
+    resource_name = Column(String)
+    resource_type = Column(String)
+    reason = Column(String)
+    estimated_monthly_savings = Column(Float)
+    scanned_at = Column(DateTime, default=datetime.datetime.utcnow)
+    tags = Column(Text, nullable=True)
+    cpu_avg_percent = Column(Float, nullable=True)
+    memory_avg_percent = Column(Float, nullable=True)
+    network_in_bytes = Column(Float, nullable=True)
+    network_out_bytes = Column(Float, nullable=True)
+    status = Column(String, default="open")  # open, fixed, dismissed, in_progress
+    status_changed_at = Column(DateTime, nullable=True)
+    first_seen_at = Column(DateTime, nullable=True)
+    region = Column(String, nullable=True)
+
+
+class ScanRun(Base):
+    __tablename__ = "scan_runs"
+    id = Column(Integer, primary_key=True, index=True)
+    status = Column(String, default="running")
+    findings_count = Column(Integer, default=0)
+    errors = Column(Text)
+    started_at = Column(DateTime, default=datetime.datetime.utcnow)
+    completed_at = Column(DateTime)
+
+
+def init_db():
+    Base.metadata.create_all(bind=engine)