granny-devops 0.4.0__py3-none-any.whl

granny/report.py

@@ -0,0 +1,128 @@
+"""SetupReport — shared infrastructure setup status tracking + markdown reports.
+
+Used across CDN, storage, edge, serverless, and email setup workflows to
+track component status and produce structured markdown reports. Generalized
+from the per-script SetupReport classes that were duplicated in 5+ files
+under ``tools/create/``.
+"""
+
+import time
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+
+STATUS_ICONS = {
+    "created": "[NEW]",
+    "exists": "[OK]",
+    "configured": "[OK]",
+    "requested": "[OK]",
+    "uploaded": "[OK]",
+    "passed": "[OK]",
+    "deployed": "[OK]",
+    "published": "[OK]",
+    "skipped": "[SKIP]",
+    "failed": "[FAIL]",
+    "pending": "[ ]",
+}
+
+
+@dataclass
+class SetupReport:
+    """Infrastructure setup report with component status tracking.
+
+    Usage::
+
+        report = SetupReport(
+            title="CDN Setup Report: example.com",
+            metadata={"Domain": "example.com", "Provider": "Bunny CDN"},
+            components=["storage_zone", "pull_zone", "dns", "ssl"],
+        )
+        report.set_status("storage_zone", "created", id=12345, region="DE")
+        report.set_url("cdn", "https://example.b-cdn.net")
+        report.set_env("BUNNY_PULL_ZONE_ID", "67890")
+        md = report.generate_markdown()
+    """
+
+    title: str
+    metadata: dict[str, str] = field(default_factory=dict)
+    components: list[str] = field(default_factory=list)
+
+    def __post_init__(self) -> None:
+        self.timestamp: str = time.strftime("%Y-%m-%d %H:%M:%S UTC", time.gmtime())
+        self._status: dict[str, dict[str, Any]] = {
+            c: {"status": "pending", "details": {}} for c in self.components
+        }
+        self._urls: dict[str, str] = {}
+        self._env_vars: dict[str, str] = {}
+
+    def set_status(self, component: str, status: str, **details: Any) -> None:
+        if component not in self._status:
+            self._status[component] = {"status": "pending", "details": {}}
+        self._status[component]["status"] = status
+        self._status[component]["details"].update(details)
+
+    def set_url(self, name: str, url: str) -> None:
+        self._urls[name] = url
+
+    def set_env(self, key: str, value: str) -> None:
+        self._env_vars[key] = value
+
+    def generate_markdown(self, *, footer: str = "") -> str:
+        lines = [
+            f"# {self.title}",
+            "",
+            f"**Generated:** {self.timestamp}",
+        ]
+        for key, value in self.metadata.items():
+            lines.append(f"**{key}:** {value}")
+        lines.extend(["", "---", "", "## Component Status", ""])
+
+        for comp_key, comp in self._status.items():
+            status = comp["status"]
+            icon = STATUS_ICONS.get(status, "[ ]")
+            display = comp_key.replace("_", " ").title()
+            lines.append(f"### {icon} {display}")
+            lines.append(f"**Status:** {status.replace('_', ' ').title()}")
+            for dk, dv in comp["details"].items():
+                label = dk.replace("_", " ").title()
+                if isinstance(dv, list):
+                    lines.append(f"- **{label}:**")
+                    for item in dv:
+                        lines.append(f"  - `{item}`")
+                else:
+                    lines.append(f"- **{label}:** `{dv}`")
+            lines.append("")
+
+        if self._urls:
+            lines.extend(["## URLs", "", "| Name | URL |", "|------|-----|"])
+            for name, url in self._urls.items():
+                lines.append(f"| {name.replace('_', ' ').title()} | {url} |")
+            lines.append("")
+
+        if footer:
+            lines.extend(["---", "", footer])
+
+        return "\n".join(lines)
+
+    def save(self, output_dir: str | Path = ".", prefix: str = "report") -> Path:
+        """Save markdown report to disk. Returns the file path."""
+        output_dir = Path(output_dir)
+        output_dir.mkdir(parents=True, exist_ok=True)
+        ts = time.strftime("%Y%m%d-%H%M%S", time.gmtime())
+        path = output_dir / f"{prefix}-{ts}.md"
+        path.write_text(self.generate_markdown(), encoding="utf-8")
+        return path
+
+    def export_deploy_env(self, path: str | Path = ".deploy.env") -> None:
+        """Write env vars to a deploy env file (append, don't overwrite)."""
+        if not self._env_vars:
+            return
+        path = Path(path)
+        existing = path.read_text(encoding="utf-8") if path.exists() else ""
+        with path.open("a", encoding="utf-8") as f:
+            if existing and not existing.endswith("\n"):
+                f.write("\n")
+            for key, value in self._env_vars.items():
+                if f"{key}=" not in existing:
+                    f.write(f"{key}={value}\n")

granny/serverless/__init__.py

@@ -0,0 +1,5 @@
+"""Serverless / FaaS provider clients — Scaleway Functions."""
+
+from granny.serverless.scaleway import ScalewayFunctionsClient
+
+__all__ = ["ScalewayFunctionsClient"]

granny/serverless/scaleway.py

@@ -0,0 +1,264 @@
+"""Scaleway Functions (FaaS) client — namespace/function/domain/trigger CRUD.
+
+Lifted from ``tools/create/setup_scaleway_faas.py:ScalewayFunctionsClient``.
+"""
+
+import json
+import logging
+from typing import Any
+
+import requests
+
+from granny.credentials.secrets import get_secret
+
+logger = logging.getLogger(__name__)
+
+SCALEWAY_REGIONS = {
+    "fr-par": {
+        "name": "Paris, France",
+        "functions_api": "https://api.scaleway.com/functions/v1beta1/regions/fr-par",
+    },
+    "nl-ams": {
+        "name": "Amsterdam, Netherlands",
+        "functions_api": "https://api.scaleway.com/functions/v1beta1/regions/nl-ams",
+    },
+    "pl-waw": {
+        "name": "Warsaw, Poland",
+        "functions_api": "https://api.scaleway.com/functions/v1beta1/regions/pl-waw",
+    },
+}
+
+SCALEWAY_RUNTIMES = [
+    "node20", "node22", "python311", "python312", "go121", "rust165",
+]
+
+
+class ScalewayFunctionsClient:
+    """Scaleway Serverless Functions management."""
+
+    def __init__(
+        self,
+        *,
+        access_key: str | None = None,
+        secret_key: str | None = None,
+        project_id: str | None = None,
+        region: str = "fr-par",
+    ) -> None:
+        self.access_key = access_key or get_secret("SCW_ACCESS_KEY")
+        self.secret_key = secret_key or get_secret("SCW_SECRET_KEY")
+        self.project_id = project_id or get_secret("SCW_DEFAULT_PROJECT_ID")
+        self.region = region
+
+        if not all([self.access_key, self.secret_key, self.project_id]):
+            raise ValueError(
+                "Missing Scaleway credentials. Set SCW_ACCESS_KEY, "
+                "SCW_SECRET_KEY, SCW_DEFAULT_PROJECT_ID (env or vault)."
+            )
+        if region not in SCALEWAY_REGIONS:
+            raise ValueError(
+                f"Unknown region: {region}. Choices: {', '.join(SCALEWAY_REGIONS)}"
+            )
+
+        self._api_base = SCALEWAY_REGIONS[region]["functions_api"]
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"X-Auth-Token": self.secret_key, "Content-Type": "application/json"}
+        )
+
+    def _request(self, method: str, path: str, data: dict | None = None) -> Any:
+        url = f"{self._api_base}{path}"
+        resp = getattr(self.session, method.lower())(url, json=data, timeout=30)
+        if resp.status_code >= 400:
+            raise RuntimeError(
+                f"Scaleway {method} {path}: {resp.status_code} {resp.text}"
+            )
+        if resp.status_code == 204 or not resp.text:
+            return {}
+        return resp.json()
+
+    # -- Namespaces ------------------------------------------------------------
+
+    def list_namespaces(self) -> list[dict]:
+        result = self._request("GET", f"/namespaces?project_id={self.project_id}")
+        return result.get("namespaces", [])
+
+    def find_namespace(self, name: str) -> dict | None:
+        for ns in self.list_namespaces():
+            if ns.get("name") == name:
+                return ns
+        return None
+
+    def get_namespace(self, namespace_id: str) -> dict:
+        return self._request("GET", f"/namespaces/{namespace_id}")
+
+    def create_namespace(
+        self,
+        name: str,
+        description: str = "",
+        *,
+        env: dict | None = None,
+        secrets: list[dict] | None = None,
+    ) -> dict:
+        data: dict[str, Any] = {
+            "name": name,
+            "project_id": self.project_id,
+            "description": description or f"Function namespace for {name}",
+        }
+        if env:
+            data["environment_variables"] = env
+        if secrets:
+            data["secret_environment_variables"] = secrets
+        result = self._request("POST", "/namespaces", data)
+        logger.info("Created namespace %s (ID %s)", name, result.get("id"))
+        return result
+
+    def delete_namespace(self, namespace_id: str) -> None:
+        self._request("DELETE", f"/namespaces/{namespace_id}")
+
+    # -- Functions -------------------------------------------------------------
+
+    def list_functions(self, namespace_id: str) -> list[dict]:
+        result = self._request("GET", f"/functions?namespace_id={namespace_id}")
+        return result.get("functions", [])
+
+    def find_function(self, namespace_id: str, name: str) -> dict | None:
+        for fn in self.list_functions(namespace_id):
+            if fn.get("name") == name:
+                return fn
+        return None
+
+    def create_function(
+        self,
+        namespace_id: str,
+        name: str,
+        *,
+        runtime: str = "node20",
+        handler: str = "handler.handler",
+        min_scale: int = 0,
+        max_scale: int = 5,
+        memory_limit: int = 256,
+        timeout: str = "30s",
+        privacy: str = "public",
+        description: str = "",
+        env: dict | None = None,
+        secrets: list[dict] | None = None,
+    ) -> dict:
+        data: dict[str, Any] = {
+            "name": name,
+            "namespace_id": namespace_id,
+            "runtime": runtime,
+            "handler": handler,
+            "min_scale": min_scale,
+            "max_scale": max_scale,
+            "memory_limit": memory_limit,
+            "timeout": timeout,
+            "http_option": "enabled",
+            "privacy": privacy,
+            "description": description or f"Function {name}",
+        }
+        if env:
+            data["environment_variables"] = env
+        if secrets:
+            data["secret_environment_variables"] = secrets
+        result = self._request("POST", "/functions", data)
+        logger.info("Created function %s (ID %s)", name, result.get("id"))
+        return result
+
+    def delete_function(self, function_id: str) -> None:
+        self._request("DELETE", f"/functions/{function_id}")
+
+    def deploy_function(self, function_id: str) -> dict:
+        return self._request("POST", f"/functions/{function_id}/deploy")
+
+    def get_upload_url(self, function_id: str, content_length: int) -> str:
+        result = self._request(
+            "GET", f"/functions/{function_id}/upload-url?content_length={content_length}"
+        )
+        url = result.get("url")
+        if not url:
+            raise RuntimeError(f"No upload URL in response: {result}")
+        return url
+
+    def update_function(
+        self,
+        function_id: str,
+        *,
+        env: dict | None = None,
+        secrets: list[dict] | None = None,
+    ) -> dict:
+        data: dict[str, Any] = {}
+        if env is not None:
+            data["environment_variables"] = env
+        if secrets is not None:
+            data["secret_environment_variables"] = secrets
+        if not data:
+            return {}
+        return self._request("PATCH", f"/functions/{function_id}", data)
+
+    def upload_package(self, function_id: str, zip_path: str) -> None:
+        """Upload a zipped function package via presigned URL."""
+        import os
+
+        size = os.path.getsize(zip_path)
+        upload_url = self.get_upload_url(function_id, size)
+        with open(zip_path, "rb") as fh:
+            resp = requests.put(
+                upload_url,
+                data=fh,
+                headers={
+                    "Content-Type": "application/octet-stream",
+                    "Content-Length": str(size),
+                },
+                timeout=600,
+            )
+        if resp.status_code not in (200, 204):
+            raise RuntimeError(
+                f"Upload failed: HTTP {resp.status_code} {resp.text[:500]}"
+            )
+        logger.info("Uploaded %d bytes to function %s", size, function_id)
+
+    def deploy_package(
+        self,
+        function_id: str,
+        zip_path: str,
+        *,
+        env: dict | None = None,
+        secrets: list[dict] | None = None,
+    ) -> dict:
+        """Upload code, sync env vars, and trigger deployment."""
+        self.upload_package(function_id, zip_path)
+        if env is not None or secrets is not None:
+            self.update_function(function_id, env=env, secrets=secrets)
+            logger.info("Synced environment variables")
+        return self.deploy_function(function_id)
+
+    # -- Domains ---------------------------------------------------------------
+
+    def list_domains(self, function_id: str) -> list[dict]:
+        result = self._request("GET", f"/domains?function_id={function_id}")
+        return result.get("domains", [])
+
+    def create_domain(self, function_id: str, hostname: str) -> dict:
+        result = self._request(
+            "POST", "/domains", {"function_id": function_id, "hostname": hostname}
+        )
+        logger.info("Added domain %s to function %s", hostname, function_id)
+        return result
+
+    # -- Triggers --------------------------------------------------------------
+
+    def list_triggers(self, function_id: str) -> list[dict]:
+        result = self._request("GET", f"/triggers?function_id={function_id}")
+        return result.get("triggers", [])
+
+    def create_cron_trigger(
+        self, function_id: str, name: str, schedule: str, args: dict | None = None
+    ) -> dict:
+        data: dict[str, Any] = {
+            "name": name,
+            "function_id": function_id,
+            "schedule": schedule,
+        }
+        if args:
+            data["args"] = json.dumps(args)
+        return self._request("POST", "/triggers", data)

granny/storage/__init__.py

@@ -0,0 +1,7 @@
+"""Storage provider clients — Bunny Storage, Hetzner S3, AWS S3."""
+
+from granny.storage.bunny import BunnyStorageClient
+from granny.storage.hetzner import HetznerS3Client
+from granny.storage.aws import AWSS3Client
+
+__all__ = ["BunnyStorageClient", "HetznerS3Client", "AWSS3Client"]

granny/storage/aws.py

@@ -0,0 +1,113 @@
+"""AWS S3 client for static website hosting.
+
+Extracted from ``tools/create/setup_s3_website.py`` and
+``tools/create/setup_aws_cloudfront.py``.
+"""
+
+import json
+import logging
+import time
+
+import boto3
+
+logger = logging.getLogger(__name__)
+
+
+def _website_endpoint(bucket: str, region: str) -> str:
+    if region == "us-east-1":
+        return f"{bucket}.s3-website-us-east-1.amazonaws.com"
+    return f"{bucket}.s3-website.{region}.amazonaws.com"
+
+
+class AWSS3Client:
+    """AWS S3 bucket management for static website hosting."""
+
+    def __init__(
+        self, *, aws_profile: str | None = None, region: str | None = None
+    ) -> None:
+        session_kwargs: dict = {}
+        if aws_profile:
+            session_kwargs["profile_name"] = aws_profile
+        if region:
+            session_kwargs["region_name"] = region
+        session = boto3.Session(**session_kwargs)
+        self.region = session.region_name or "us-east-1"
+        self.client = session.client("s3")
+
+    def bucket_exists(self, bucket_name: str) -> bool:
+        try:
+            self.client.head_bucket(Bucket=bucket_name)
+            return True
+        except Exception:
+            return False
+
+    def create_bucket(self, bucket_name: str) -> None:
+        if self.bucket_exists(bucket_name):
+            logger.info("Bucket %s already exists", bucket_name)
+            return
+        kwargs: dict = {"Bucket": bucket_name}
+        if self.region != "us-east-1":
+            kwargs["CreateBucketConfiguration"] = {
+                "LocationConstraint": self.region
+            }
+        self.client.create_bucket(**kwargs)
+        logger.info("Created bucket %s in %s", bucket_name, self.region)
+
+    def enable_website_hosting(
+        self, bucket_name: str, index: str = "index.html", error: str = "error.html"
+    ) -> None:
+        """Enable static website hosting with public-read policy."""
+        # Disable block-public-access
+        self.client.put_public_access_block(
+            Bucket=bucket_name,
+            PublicAccessBlockConfiguration={
+                "BlockPublicAcls": False,
+                "IgnorePublicAcls": False,
+                "BlockPublicPolicy": False,
+                "RestrictPublicBuckets": False,
+            },
+        )
+        time.sleep(5)
+
+        self.client.put_bucket_website(
+            Bucket=bucket_name,
+            WebsiteConfiguration={
+                "IndexDocument": {"Suffix": index},
+                "ErrorDocument": {"Key": error},
+            },
+        )
+
+        policy = {
+            "Version": "2012-10-17",
+            "Statement": [
+                {
+                    "Sid": "PublicReadGetObject",
+                    "Effect": "Allow",
+                    "Principal": "*",
+                    "Action": "s3:GetObject",
+                    "Resource": f"arn:aws:s3:::{bucket_name}/*",
+                }
+            ],
+        }
+        self.client.put_bucket_policy(Bucket=bucket_name, Policy=json.dumps(policy))
+        logger.info("Website hosting enabled on %s", bucket_name)
+
+    def upload_file(
+        self,
+        bucket_name: str,
+        key: str,
+        content: str | bytes,
+        content_type: str = "text/html",
+        cache_control: str = "max-age=300",
+    ) -> None:
+        body = content.encode("utf-8") if isinstance(content, str) else content
+        self.client.put_object(
+            Bucket=bucket_name,
+            Key=key,
+            Body=body,
+            ContentType=content_type,
+            CacheControl=cache_control,
+        )
+
+    def get_website_endpoint(self, bucket_name: str) -> str:
+        return _website_endpoint(bucket_name, self.region)

granny/storage/bunny.py

@@ -0,0 +1,98 @@
+"""Bunny Storage zone client — CRUD + file upload.
+
+Lifted from ``tools/create/setup_bunny_storage.py:BunnyStorageClient``.
+"""
+
+import logging
+from typing import Any
+
+import requests
+
+from granny.credentials.secrets import get_bunny_api_key
+
+logger = logging.getLogger(__name__)
+
+API_BASE = "https://api.bunny.net"
+
+BUNNY_STORAGE_REGIONS = {
+    "DE": {"name": "Frankfurt, Germany", "hostname": "storage.bunnycdn.com"},
+    "UK": {"name": "London, UK", "hostname": "uk.storage.bunnycdn.com"},
+    "NY": {"name": "New York, US", "hostname": "ny.storage.bunnycdn.com"},
+    "LA": {"name": "Los Angeles, US", "hostname": "la.storage.bunnycdn.com"},
+    "SG": {"name": "Singapore", "hostname": "sg.storage.bunnycdn.com"},
+    "SE": {"name": "Stockholm, Sweden", "hostname": "se.storage.bunnycdn.com"},
+    "BR": {"name": "Sao Paulo, Brazil", "hostname": "br.storage.bunnycdn.com"},
+    "JH": {"name": "Johannesburg, SA", "hostname": "jh.storage.bunnycdn.com"},
+    "SYD": {"name": "Sydney, Australia", "hostname": "syd.storage.bunnycdn.com"},
+}
+
+
+class BunnyStorageClient:
+    """Bunny Storage zone management and file upload."""
+
+    def __init__(self, api_key: str | None = None, customer: str | None = None) -> None:
+        api_key = api_key or get_bunny_api_key(customer)
+        if not api_key:
+            raise ValueError("BUNNY_API_KEY not set (env or vault).")
+        self._api_key = api_key
+        self.session = requests.Session()
+        self.session.headers.update(
+            {"AccessKey": api_key, "Content-Type": "application/json"}
+        )
+
+    def _request(self, method: str, path: str, data: dict | None = None) -> Any:
+        url = f"{API_BASE}{path}"
+        resp = getattr(self.session, method.lower())(url, json=data, timeout=30)
+        if resp.status_code >= 400:
+            raise RuntimeError(
+                f"Bunny Storage {method} {path}: {resp.status_code} {resp.text}"
+            )
+        if resp.status_code == 204 or not resp.text:
+            return {}
+        return resp.json()
+
+    def list_storage_zones(self) -> list[dict]:
+        return self._request("GET", "/storagezone")
+
+    def find_storage_zone(self, name: str) -> dict | None:
+        for zone in self.list_storage_zones():
+            if zone.get("Name") == name:
+                return zone
+        return None
+
+    def create_storage_zone(self, name: str, region: str = "DE") -> dict:
+        result = self._request(
+            "POST",
+            "/storagezone",
+            {"Name": name, "Region": region, "ZoneTier": 0},
+        )
+        logger.info("Created storage zone %s (ID %s)", name, result.get("Id"))
+        return result
+
+    def delete_storage_zone(self, zone_id: int) -> None:
+        self._request("DELETE", f"/storagezone/{zone_id}")
+        logger.info("Deleted storage zone %s", zone_id)
+
+    def upload_file(
+        self,
+        storage_hostname: str,
+        storage_password: str,
+        zone_name: str,
+        path: str,
+        content: bytes,
+        content_type: str | None = None,
+        cache_control: str | None = None,
+    ) -> None:
+        """Upload a file to a storage zone via the storage endpoint."""
+        url = f"https://{storage_hostname}/{zone_name}/{path}"
+        headers: dict[str, str] = {"AccessKey": storage_password}
+        if content_type:
+            headers["Content-Type"] = content_type
+        if cache_control:
+            headers["Cache-Control"] = cache_control
+        resp = requests.put(url, data=content, headers=headers, timeout=30)
+        if resp.status_code not in (200, 201):
+            raise RuntimeError(
+                f"Upload {path} failed: {resp.status_code} {resp.text}"
+            )
+        logger.info("Uploaded %s to %s/%s", path, zone_name, path)