cloudsim 1.0.0__py3-none-any.whl

cloudsim/.env.example

@@ -0,0 +1,14 @@
+# Example environment for CloudSim
+
+# Where CloudSim writes runtime state (VM folders and SQLite state).
+# Recommended: set an absolute path.
+# Windows example: E:\cloudsim-workspace
+# macOS/Linux example: /home/you/cloudsim-workspace
+CLOUDSIM_WORKSPACE=cloudsim-workspace
+
+# Optional: real PostgreSQL admin connection (for real Cloud SQL simulation)
+CLOUDSIM_PG_HOST=127.0.0.1
+CLOUDSIM_PG_PORT=5432
+CLOUDSIM_PG_ADMIN_USER=postgres
+CLOUDSIM_PG_ADMIN_PASSWORD=pg123
+CLOUDSIM_PG_ADMIN_DB=postgres

cloudsim/__init__.py

@@ -0,0 +1 @@
+"""Nimbus Cloud Simulator backend package."""

cloudsim/app.py

@@ -0,0 +1,26 @@
+import argparse
+import sys
+from cloudsim.web.app_factory import create_app
+
+app = create_app()
+
+
+def main(argv: list[str] | None = None) -> int:
+    if argv is None:
+        argv = sys.argv[1:]
+
+    parser = argparse.ArgumentParser(prog="cloudsim-server", description="Start the CloudSim API server.")
+    parser.add_argument("--host", default="127.0.0.1", help="The interface to bind to (default: 127.0.0.1)")
+    parser.add_argument("--port", type=int, default=5000, help="The port to bind to (default: 5000)")
+    parser.add_argument("--debug", action="store_true", help="Enable Flask debug mode")
+    
+    args = parser.parse_args(argv)
+
+    print(f"[*] Starting CloudSim Server on {args.host}:{args.port} (debug={args.debug})")
+    app.run(host=args.host, port=args.port, debug=args.debug)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())
+

cloudsim/cli.py

@@ -0,0 +1,10 @@
+from __future__ import annotations
+
+import sys
+
+from cloudsim.cli_services.main import main
+
+
+if __name__ == "__main__":
+    raise SystemExit(main(sys.argv[1:]))
+

cloudsim/cli_services/common.py

@@ -0,0 +1,74 @@
+from __future__ import annotations
+
+import json
+import os
+import urllib.error
+import urllib.request
+from pathlib import Path
+from typing import Any
+
+from cloudsim import paths
+
+DEFAULT_API_URL = os.environ.get("CLOUDSIM_API_URL", "http://127.0.0.1:5000").rstrip("/")
+
+
+def get_repo_root() -> Path:
+    # Keep legacy name used across CLI handlers; this is the workspace root.
+    return paths.workspace_root()
+
+
+class CliError(Exception):
+    def __init__(self, message: str, status_code: int = 1) -> None:
+        super().__init__(message)
+        self.message = message
+        self.status_code = status_code
+
+
+def _parse_json(value: str, label: str) -> Any:
+    try:
+        return json.loads(value)
+    except json.JSONDecodeError as error:
+        raise CliError(f"Invalid JSON for {label}: {error.msg}") from error
+
+
+def _request(base_url: str, method: str, path: str, payload: dict[str, Any] | None = None) -> dict[str, Any]:
+    url = f"{base_url}{path}"
+    headers = {"Content-Type": "application/json"}
+    body = None if payload is None else json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(url=url, method=method, data=body, headers=headers)
+    try:
+        with urllib.request.urlopen(req, timeout=15) as response:
+            raw = response.read().decode("utf-8")
+            data = json.loads(raw) if raw else {}
+    except urllib.error.HTTPError as error:
+        raw = error.read().decode("utf-8")
+        message = f"HTTP {error.code}"
+        if raw:
+            try:
+                data = json.loads(raw)
+                message = data.get("error") or data.get("message") or message
+            except json.JSONDecodeError:
+                message = f"{message}: {raw}"
+        raise CliError(message, status_code=error.code)
+    except urllib.error.URLError as error:
+        raise CliError(f"Unable to reach backend at {base_url}: {error}") from error
+    except json.JSONDecodeError as error:
+        raise CliError(f"Invalid JSON response from backend: {error}") from error
+
+    if isinstance(data, dict) and data.get("ok") is False:
+        raise CliError(str(data.get("error") or "Request failed"))
+    return data
+
+
+def _print(data: Any, key: str | None = None) -> None:
+    if key and isinstance(data, dict):
+        if "state" in data:
+            data = data["state"]
+        if key in data:
+            target = data[key]
+            if isinstance(target, list) and target:
+                print(json.dumps(target[0], indent=2, sort_keys=True))
+            else:
+                print(json.dumps(target, indent=2, sort_keys=True))
+            return
+    print(json.dumps(data, indent=2, sort_keys=True))

cloudsim/cli_services/handlers/autoscale.py

@@ -0,0 +1,286 @@
+from __future__ import annotations
+
+import argparse
+import itertools
+import time
+from typing import Any, Callable
+
+from ..common import CliError, _request
+
+
+def _prompt_yes_no(question: str, default_yes: bool = True) -> bool:
+    suffix = " [Y/n]: " if default_yes else " [y/N]: "
+    raw = input(question + suffix).strip().lower()
+    if not raw:
+        return default_yes
+    return raw in {"y", "yes"}
+
+
+def _find_running_vm_count_for_lb(state: dict[str, Any], lb_id: str) -> int:
+    lb = next((item for item in state.get("lbs", []) if item.get("id") == lb_id), None)
+    if not lb:
+        return 0
+    vm_ids = set(lb.get("backendVmIds", []))
+    return sum(1 for vm in state.get("vms", []) if vm.get("id") in vm_ids and vm.get("status") == "running")
+
+
+def _find_running_autoscaled_count_for_lb(state: dict[str, Any], lb_id: str) -> int:
+    lb = next((item for item in state.get("lbs", []) if item.get("id") == lb_id), None)
+    if not lb:
+        return 0
+    vm_ids = set(lb.get("backendVmIds", []))
+    return sum(
+        1
+        for vm in state.get("vms", [])
+        if vm.get("id") in vm_ids
+        and vm.get("status") == "running"
+        and vm.get("autoScaled")
+        and vm.get("autoScaledForLbId") == lb_id
+    )
+
+
+def _wait_for_state(
+    args: argparse.Namespace,
+    condition: Callable[[dict[str, Any]], bool],
+    label: str,
+    timeout_seconds: float = 20.0,
+    poll_seconds: float = 0.5,
+) -> dict[str, Any]:
+    spinner = itertools.cycle(["|", "/", "-", "\\"])
+    deadline = time.time() + timeout_seconds
+    last_state: dict[str, Any] = {}
+    while time.time() < deadline:
+        response = _request(args.base_url, "GET", "/api/state")
+        state = response.get("state", {})
+        last_state = state
+        if condition(state):
+            print(f"\r{label} ... done                ")
+            return state
+        print(f"\r{label} ... {next(spinner)}", end="", flush=True)
+        time.sleep(poll_seconds)
+    print("")
+    raise CliError(f"Timeout while waiting: {label}")
+
+
+def _animate_autoscale_spinup(
+    args: argparse.Namespace,
+    lb_id: str,
+    autoscaled_now: int,
+    target_total: int,
+    step_delay_seconds: float,
+) -> dict[str, Any]:
+    spinner = itertools.cycle(["|", "/", "-", "\\"])
+    deadline = time.time() + max(30.0, autoscaled_now * (step_delay_seconds + 3.0))
+    next_stage_at = time.time() + 0.1
+    required_autoscaled = 0
+    last_state: dict[str, Any] = {}
+    announced_vms: set[str] = set()
+
+    print("\n[*] COMPUTE ENGINE: Signal received. Initializing lifecycle events...")
+
+    while time.time() < deadline:
+        response = _request(args.base_url, "GET", "/api/state")
+        state = response.get("state", {})
+        last_state = state
+
+        lb = next((item for item in state.get("lbs", []) if item.get("id") == lb_id), None)
+        lb_vm_ids = set(lb.get("backendVmIds", [])) if lb else set()
+
+        running_total = _find_running_vm_count_for_lb(state, lb_id)
+        running_autoscaled = _find_running_autoscaled_count_for_lb(state, lb_id)
+
+        # Notify when an instance becomes ready
+        for vm in state.get("vms", []):
+            v_id = vm.get("id")
+            if not v_id:
+                continue
+            if v_id in lb_vm_ids and vm.get("status") == "running" and v_id not in announced_vms:
+                announced_vms.add(v_id)
+                prefix = "[AUTO]" if vm.get("autoScaled") else "[BASE]"
+                print(f"\r  {prefix} Instance {v_id} is healthy. (port {vm.get('reservedPort')})        ")
+
+        now = time.time()
+        if autoscaled_now > 0 and now >= next_stage_at and required_autoscaled < autoscaled_now:
+            required_autoscaled += 1
+            next_stage_at = now + step_delay_seconds
+
+        stage_met = running_autoscaled >= required_autoscaled
+        total_met = running_total >= target_total
+
+        progress = (running_total / target_total) if target_total > 0 else 0
+        bar_len = 20
+        filled = int(progress * bar_len)
+        bar = "#" * filled + "." * (bar_len - filled)
+
+        status_text = (
+            f"\r{next(spinner)} [{bar}] Scaling compute footprint... "
+            f"({running_total}/{target_total} active) "
+        )
+        print(status_text, end="", flush=True)
+
+        if stage_met and total_met and required_autoscaled >= autoscaled_now:
+            print(f"\r[OK] [{bar}] Fleet stabilization complete. ({target_total}/{target_total} active)          \n")
+            return state
+        time.sleep(0.15)
+
+    print("")
+    raise CliError("Fleet took too long to stabilize.")
+
+
+def _handle_autoscale_test(args: argparse.Namespace) -> None:
+    print("\n" + "=" * 60)
+    print("CLOUDSIM AUTOSCALE LABORATORY".center(60))
+    print("=" * 60)
+    print("This scenario simulates a high-traffic event to trigger autoscaling.")
+
+    if not _prompt_yes_no("Launch infrastructure simulation?", default_yes=True):
+        print("Cancelled.")
+        return
+
+    state = _request(args.base_url, "GET", "/api/state").get("state", {})
+    constants = state.get("constants", {})
+    backend_profiles = state.get("backendProfiles", [])
+    if not backend_profiles:
+        raise CliError("No backend profiles available from server state.")
+
+    region = constants.get("vmRegions", ["us-central1"])[0]
+    machine = constants.get("vmMachineTypes", ["e2-standard-2"])[0]
+    image = constants.get("vmImages", ["Ubuntu 22.04 LTS"])[0]
+    backend_profile_id = backend_profiles[0].get("id", "python-fastapi")
+    endpoint_key = "GET /health"
+
+    print(f"\n[*] Provisioning static resources in {region}...")
+    vm_name = f"as-base-{int(time.time())}"
+    vm_payload = {
+        "name": vm_name,
+        "region": region,
+        "machineType": machine,
+        "image": image,
+        "backendProfileId": backend_profile_id,
+        "runtimeMode": "profile",
+        "scriptPath": "",
+    }
+    vm_resp = _request(args.base_url, "POST", "/api/vms", vm_payload)
+    base_vm_id = vm_resp["state"]["vms"][0]["id"]
+
+    _wait_for_state(
+        args,
+        lambda s: any(vm.get("id") == base_vm_id and vm.get("status") == "running" for vm in s.get("vms", [])),
+        "Wait: Base VM boot",
+    )
+
+    lb_name = f"as-lb-{int(time.time())}"
+    lb_payload = {
+        "name": lb_name,
+        "type": "HTTP(S)",
+        "region": constants.get("lbRegions", ["global"])[0],
+        "distributionAlgorithmId": "round_robin",
+        "backendVmIds": [base_vm_id],
+        "autoScaleProfileId": "aggressive",
+        "queueServiceTier": "disabled",
+        "cloudArmorPolicyId": "relaxed",
+    }
+    lb_resp = _request(args.base_url, "POST", "/api/load-balancers", lb_payload)
+    lb_id = lb_resp["state"]["lbs"][0]["id"]
+
+    _wait_for_state(
+        args,
+        lambda s: any(lb.get("id") == lb_id and lb.get("status") == "active" for lb in s.get("lbs", [])),
+        "Wait: LB Propagation",
+    )
+
+    print(f"\n[!] READY: Load Balancer {lb_id} is live with 1 backend.")
+    if not _prompt_yes_no("Initiate traffic spike?", default_yes=True):
+        print("Test aborted.")
+        return
+
+    print(f"\n[*] BURST: Sending {args.requests} requests to {lb_id}...")
+    simulate_payload = {
+        "lbId": lb_id,
+        "endpointKey": endpoint_key,
+        "requests": args.requests,
+        "clientId": "autoscale-lab-client",
+    }
+    sim_resp = _request(args.base_url, "POST", "/api/simulate", simulate_payload)
+    traffic = sim_resp.get("state", {}).get("lastTrafficResult", {}) or {}
+    autoscaled_now = int(traffic.get("autoscaledCount", 0))
+    target_total = min(args.max_instances, 1 + max(0, autoscaled_now))
+
+    print(f"[*] RESPONSE: Autoscaler detected overload. Triggering +{autoscaled_now} instances.")
+
+    state = _animate_autoscale_spinup(
+        args=args,
+        lb_id=lb_id,
+        autoscaled_now=autoscaled_now,
+        target_total=target_total,
+        step_delay_seconds=args.spinup_delay,
+    )
+
+    print("=" * 60)
+    print("TRAFFIC DISTRIBUTION ANALYSIS".center(60))
+    print("-" * 60)
+    vm_usage = traffic.get("vmUsage", {})
+    total_served = int(traffic.get("served", 0) or 0)
+    print(f"  Total Requests Processed: {total_served}")
+    print(f"  Average Latency:          {traffic.get('avgLatencyMs')}ms")
+    print(f"  Distribution Algorithm:   {traffic.get('distributionAlgorithmId')}")
+    print("\n  INSTANCE RELAY MAP:")
+
+    lb = next((item for item in state.get("lbs", []) if item.get("id") == lb_id), None)
+    vm_ids = lb.get("backendVmIds", []) if lb else []
+
+    for v_id in vm_ids:
+        vm = next((v for v in state.get("vms", []) if v.get("id") == v_id), None)
+        if not vm:
+            continue
+        count = int(vm_usage.get(v_id, 0) or 0)
+        share = (count / total_served * 100) if total_served > 0 else 0
+        tag = "[AUTO]" if vm.get("autoScaled") else "[BASE]"
+        status_mark = "*" if vm.get("status") == "running" else "!"
+        bar = "#" * int(share / 5)
+        print(f"    {status_mark} {v_id} {tag:<6} | {count:4} reqs ({share:4.1f}%) {bar}")
+    print("=" * 60 + "\n")
+
+    if _prompt_yes_no("Destroy ephemeral resources?", default_yes=True):
+        current_state = _request(args.base_url, "GET", "/api/state").get("state", {})
+        lb_current = next((item for item in current_state.get("lbs", []) if item.get("id") == lb_id), None)
+        lb_vm_ids = set(lb_current.get("backendVmIds", [])) if lb_current else set()
+        autoscaled = [
+            vm
+            for vm in current_state.get("vms", [])
+            if vm.get("id") in lb_vm_ids
+            and vm.get("autoScaled")
+            and vm.get("autoScaledForLbId") == lb_id
+        ]
+        autoscaled_ids = [vm.get("id") for vm in autoscaled if vm.get("id")]
+        for vm_id in autoscaled_ids:
+            _request(args.base_url, "DELETE", f"/api/vms/{vm_id}")
+
+        time.sleep(0.4)
+        verify_state = _request(args.base_url, "GET", "/api/state").get("state", {})
+        remaining_ids = {
+            vm.get("id")
+            for vm in verify_state.get("vms", [])
+            if vm.get("autoScaled") and vm.get("autoScaledForLbId") == lb_id
+        }
+        retry_ids = [vm_id for vm_id in autoscaled_ids if vm_id in remaining_ids]
+        for vm_id in retry_ids:
+            _request(args.base_url, "DELETE", f"/api/vms/{vm_id}")
+
+        final_state = _request(args.base_url, "GET", "/api/state").get("state", {})
+        final_remaining = [
+            vm.get("id")
+            for vm in final_state.get("vms", [])
+            if vm.get("autoScaled") and vm.get("autoScaledForLbId") == lb_id
+        ]
+        destroyed_count = len(autoscaled_ids) - len(final_remaining)
+        print(f"Destroyed {destroyed_count} auto-scaled VM(s).")
+        if final_remaining:
+            print(f"Warning: still present auto-scaled VM(s): {', '.join(final_remaining)}")
+    else:
+        print("Kept auto-scaled VM(s) running.")
+
+    if _prompt_yes_no("Destroy temporary LB and base VM too?", default_yes=False):
+        _request(args.base_url, "DELETE", f"/api/load-balancers/{lb_id}")
+        _request(args.base_url, "DELETE", f"/api/vms/{base_vm_id}")
+        print("Destroyed temporary LB and base VM.")

cloudsim/cli_services/handlers/config.py

@@ -0,0 +1,174 @@
+from __future__ import annotations
+
+import argparse
+import os
+from pathlib import Path
+
+import cloudsim
+from cloudsim.paths import (
+    autoscale_vms_dir,
+    ensure_state_dir,
+    read_global_config,
+    vms_dir,
+    workspace_root,
+    write_global_config,
+)
+from cloudsim.web.env_loader import load_env_file
+
+from ..common import CliError, _print
+
+
+def _package_env_example_path() -> Path:
+    return Path(cloudsim.__file__).resolve().parent / ".env.example"
+
+
+def _render_env_from_example(example_text: str, workspace: Path) -> str:
+    lines = example_text.splitlines()
+
+    def is_ws_line(line: str) -> bool:
+        return line.strip().startswith("CLOUDSIM_WORKSPACE=")
+
+    out: list[str] = []
+    replaced = False
+    for line in lines:
+        if is_ws_line(line):
+            out.append(f"CLOUDSIM_WORKSPACE={workspace}")
+            replaced = True
+        else:
+            out.append(line)
+
+    if not replaced:
+        out.append(f"CLOUDSIM_WORKSPACE={workspace}")
+
+    return "\n".join(out).rstrip() + "\n"
+
+
+def _handle_config_init(args: argparse.Namespace) -> None:
+    ws = (args.workspace or "").strip()
+    if ws:
+        workspace = Path(ws).expanduser().resolve()
+    else:
+        workspace = workspace_root()
+
+    # Ensure this process uses the chosen workspace immediately (even if user didn't export env yet).
+    os.environ["CLOUDSIM_WORKSPACE"] = str(workspace)
+
+    workspace.mkdir(parents=True, exist_ok=True)
+
+    # Create expected top-level dirs.
+    ensure_state_dir()
+    vms_dir().mkdir(parents=True, exist_ok=True)
+    autoscale_vms_dir().mkdir(parents=True, exist_ok=True)
+
+    env_path = workspace / ".env"
+    if env_path.exists() and not args.force:
+        raise CliError(f"{env_path} already exists. Use --force to overwrite.")
+
+    example_path = _package_env_example_path()
+    if not example_path.exists():
+        raise CliError(f"Missing packaged env example at {example_path}")
+
+    rendered = _render_env_from_example(example_path.read_text(encoding="utf-8"), workspace)
+    env_path.write_text(rendered, encoding="utf-8")
+
+    # Load it for this process so immediate follow-up commands work.
+    load_env_file(env_path)
+
+    default_cfg_path = ""
+    if not getattr(args, "no_default", False):
+        cfg = read_global_config()
+        if not isinstance(cfg, dict):
+            cfg = {}
+        cfg["workspace"] = str(workspace)
+        default_cfg_path = str(write_global_config(cfg))
+
+    _print(
+        {
+            "ok": True,
+            "workspace": str(workspace),
+            "envFile": str(env_path),
+            "defaultConfig": default_cfg_path,
+            "next": {
+                "windowsPowerShellSession": f"$env:CLOUDSIM_WORKSPACE = '{workspace}'",
+                "windowsPermanentUser": f'setx CLOUDSIM_WORKSPACE "{workspace}"',
+                "macLinuxSession": f'export CLOUDSIM_WORKSPACE="{workspace}"',
+            },
+        }
+    )
+
+
+def _mask(value: str) -> str:
+    if not value:
+        return ""
+    if len(value) <= 4:
+        return "****"
+    return value[:2] + "****" + value[-2:]
+
+
+def _handle_config_show(args: argparse.Namespace) -> None:
+    # Show how workspace was resolved.
+    ws_env = (os.environ.get("CLOUDSIM_WORKSPACE") or "").strip()
+    cfg = read_global_config()
+    ws_cfg = (cfg.get("workspace") or "").strip() if isinstance(cfg, dict) else ""
+
+    # Prefer reporting the *stable* source a new user relies on.
+    # If both env and default config exist but disagree, treat env as an override.
+    if ws_env and ws_cfg and Path(ws_env).expanduser().resolve() != Path(ws_cfg).expanduser().resolve():
+        source = "env_override"
+    elif ws_cfg:
+        source = "default_config"
+    elif ws_env:
+        source = "env"
+    else:
+        source = "cwd"
+
+    ws = workspace_root()
+    env_path = ws / ".env"
+
+    # Parse .env without mutating env (for display).
+    env_keys: list[str] = []
+    if env_path.exists():
+        for raw_line in env_path.read_text(encoding="utf-8").splitlines():
+            line = raw_line.strip()
+            if not line or line.startswith("#"):
+                continue
+            if "=" not in line:
+                continue
+            k = line.split("=", 1)[0].strip()
+            if k:
+                env_keys.append(k)
+
+    # Load it for this process too (safe: env_loader won't override explicit env vars).
+    load_env_file(env_path)
+
+    def getenv(k: str) -> str:
+        return (os.environ.get(k) or "").strip()
+
+    pg = {
+        "host": getenv("CLOUDSIM_PG_HOST"),
+        "port": getenv("CLOUDSIM_PG_PORT"),
+        "adminUser": getenv("CLOUDSIM_PG_ADMIN_USER"),
+        "adminPassword": _mask(getenv("CLOUDSIM_PG_ADMIN_PASSWORD")),
+        "adminDb": getenv("CLOUDSIM_PG_ADMIN_DB"),
+    }
+
+    _print(
+        {
+            "ok": True,
+            "workspaceSource": source,
+            "workspace": str(ws),
+            "envFile": str(env_path),
+            "envFileExists": env_path.exists(),
+            "envFileKeys": sorted(list(set(env_keys))),
+            "postgresConfigured": all(
+                [
+                    pg["host"],
+                    pg["port"],
+                    pg["adminUser"],
+                    getenv("CLOUDSIM_PG_ADMIN_PASSWORD"),
+                    pg["adminDb"],
+                ]
+            ),
+            "postgres": pg,
+        }
+    )