py-serverless-kit 0.1.0__py3-none-any.whl

py_serverless_kit/providers/__init__.py

@@ -0,0 +1,15 @@
+from .base import Artifact, Issue, Provider, ProviderError, RenderContext
+from .registry import all_providers, available, get_provider
+from .terraform_doc import TerraformDoc
+
+__all__ = [
+    "Artifact",
+    "Issue",
+    "Provider",
+    "ProviderError",
+    "RenderContext",
+    "TerraformDoc",
+    "all_providers",
+    "available",
+    "get_provider",
+]

py_serverless_kit/providers/alibaba.py

@@ -0,0 +1,268 @@
+"""Alibaba Cloud: Function Compute 3.0 + HTTP / timer / OSS / MNS-topic triggers."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Dict, List, Optional
+
+from ..config.schema import FunctionConfig, ServiceConfig
+from ..runtime.adapters.base import envelope
+from . import schedule as sched
+from .base import HTTP, SCHEDULE, STORAGE, TOPIC, Issue, Provider, RenderContext
+from .terraform_doc import TerraformDoc, escape, ref, tf_id
+
+FUNCTION = "alicloud_fcv3_function"
+TRIGGER = "alicloud_fcv3_trigger"
+ALL_METHODS = ["GET", "POST", "PUT", "DELETE", "PATCH", "HEAD", "OPTIONS"]
+_TRUST = json.dumps(
+    {
+        "Version": "1",
+        "Statement": [
+            {
+                "Action": "sts:AssumeRole",
+                "Effect": "Allow",
+                "Principal": {"Service": ["oss.aliyuncs.com", "mns.aliyuncs.com"]},
+            }
+        ],
+    }
+)
+
+
+class AlibabaProvider(Provider):
+    name = "alibaba"
+    display_name = "Alibaba Cloud Function Compute"
+    tier = "beta"
+    terraform_source = "aliyun/alicloud"
+    terraform_version = ">= 1.230.0"
+    terraform_local_name = "alicloud"
+    default_region = "cn-hangzhou"
+    capabilities = frozenset({HTTP, SCHEDULE, STORAGE, TOPIC})
+    max_name_length = 64
+    name_pattern = r"[^a-z0-9_-]"
+    runtimes = {"python3.9": "python3.9", "python3.10": "python3.10", "python3.12": "python3.12"}
+    vendor_dependencies = True
+    max_timeout = 3600  # FC allows up to 86400s, but the config schema caps timeout at 3600
+    notes = (
+        "FC 3.0 with one HTTP trigger per function (fcapp.run URL); schedules via timer triggers; "
+        "OSS and MNS-topic triggers; workflows run on the embedded engine."
+    )
+
+    # ------------------------------------------------------------------ bundle
+    def shim_files(self, config: ServiceConfig) -> Dict[str, str]:
+        return {
+            "index.py": (
+                "# Generated by py-serverless-kit. Function Compute handler: index.handler\n"
+                "from py_serverless_kit.runtime.adapters.alibaba import handler  # noqa: F401\n"
+            )
+        }
+
+    def provider_block(self, ctx: RenderContext) -> Dict[str, Any]:
+        block: Dict[str, Any] = {"region": ctx.region}
+        if ctx.opt("profile"):
+            block["profile"] = ctx.opt("profile")
+        return block
+
+    def extra_validation(self, config: ServiceConfig) -> List[Issue]:
+        issues = []
+        if config.provider.iam.statements:
+            issues.append(
+                Issue(
+                    "warning",
+                    "iam.statements are not translated to RAM policies on Alibaba; set iam.role to an existing "
+                    "RAM role ARN with the permissions your functions need",
+                    "provider.iam",
+                )
+            )
+        for name, fn in config.functions.items():
+            if fn.iam.statements:
+                issues.append(
+                    Issue("warning", "iam.statements are ignored on Alibaba; use iam.role", f"functions.{name}.iam")
+                )
+            for ev in fn.events_of("http"):
+                if ev.auth not in ("none",):
+                    issues.append(
+                        Issue(
+                            "error",
+                            f"http auth `{ev.auth}` is not supported on Alibaba (use none)",
+                            f"functions.{name}",
+                        )
+                    )
+        return issues
+
+    # ------------------------------------------------------------------ render
+    def render_resources(self, doc: TerraformDoc, ctx: RenderContext) -> None:
+        cfg = ctx.config
+        needs_role = any(fn.events_of("storage") or fn.events_of("topic") for fn in cfg.functions.values())
+        role_arn = self._trigger_role(doc, ctx) if needs_role else None
+        account = doc.data("alicloud_account", "current", {}) if needs_role else None
+
+        fn_out: Dict[str, Dict[str, Any]] = {}
+        endpoint: Optional[str] = None
+        for name, fn in ctx.function_items():
+            res = self._function(doc, ctx, name, fn)
+            out: Dict[str, Any] = {
+                "id": ref(res, "function_name"),
+                "arn": ref(res, "function_arn"),
+                "console": f"https://fcnext.console.aliyun.com/{ctx.region}/functions/{ctx.physical_name(name)}",
+            }
+            http_events = fn.events_of("http")
+            if http_events:
+                trig = self._http(doc, name, res, http_events)
+                url = ref(trig, "http_trigger[0].url_internet")
+                out["url"] = url
+                out["base_url"] = url
+                endpoint = endpoint or url
+            for i, ev in enumerate(fn.events_of("schedule")):
+                self._timer(doc, name, res, i, ev)
+            for ev in fn.events_of("storage"):
+                self._oss(doc, ctx, name, res, ev, role_arn, account)
+            for ev in fn.events_of("topic"):
+                self._mns_topic(doc, ctx, name, res, ev, role_arn, account)
+            fn_out[name] = out
+
+        wf_out = {n: {"id": ref(FUNCTION, tf_id(f"{n}-orchestrator"), "function_name")} for n in sorted(cfg.workflows)}
+        doc.output(
+            "pskit",
+            {"functions": fn_out, "workflows": wf_out, "endpoint": endpoint},
+            description="py-serverless-kit deployment summary",
+        )
+
+    # ------------------------------------------------------------------ pieces
+    def _trigger_role(self, doc: TerraformDoc, ctx: RenderContext) -> str:
+        role = doc.resource(
+            "alicloud_ram_role",
+            "triggers",
+            {
+                "role_name": ctx.physical_name("triggers")[:64],
+                "assume_role_policy_document": _TRUST,
+                "description": f"py-serverless-kit trigger role for {ctx.prefix}",
+                "force": True,
+            },
+        )
+        doc.resource(
+            "alicloud_ram_role_policy_attachment",
+            "triggers-invoke",
+            {"role_name": ref(role, "role_name"), "policy_name": "AliyunFCInvocationAccess", "policy_type": "System"},
+        )
+        return ref(role, "arn")
+
+    def _function(self, doc: TerraformDoc, ctx: RenderContext, name: str, fn: FunctionConfig) -> str:
+        cfg = ctx.config
+        body: Dict[str, Any] = {
+            "function_name": ctx.physical_name(name),
+            "description": fn.description[:256],
+            "handler": "index.handler",
+            "runtime": self.runtime_id(cfg.runtime_of(fn)),
+            "memory_size": cfg.memory_of(fn),
+            "timeout": cfg.timeout_of(fn),
+            "internet_access": True,
+            "environment_variables": {k: escape(v) for k, v in ctx.environment(name, fn).items()},
+            "code": {"zip_file": '${filebase64("${path.module}/artifact.zip")}'},
+            "tags": ctx.tags(fn),
+        }
+        role = fn.iam.role or cfg.provider.iam.role
+        if role:
+            body["role"] = role
+        if fn.concurrency:
+            body["instance_concurrency"] = fn.concurrency
+        body.update(fn.options)  # escape hatch: vpc_config, layers, log_config, ...
+        return doc.resource(FUNCTION, name, body)
+
+    def _http(self, doc: TerraformDoc, name: str, fn_res: str, events: List[Any]) -> str:
+        methods: List[str] = []
+        for ev in events:
+            for m in ALL_METHODS if ev.method == "ANY" else [ev.method]:
+                if m not in methods:
+                    methods.append(m)
+        if any(ev.cors_config is not None for ev in events) and "OPTIONS" not in methods:
+            methods.append("OPTIONS")
+        config = {"authType": "anonymous", "methods": methods, "disableURLInternet": False}
+        return doc.resource(
+            TRIGGER,
+            f"{name}-http",
+            {
+                "function_name": ref(fn_res, "function_name"),
+                "trigger_name": "http",
+                "trigger_type": "http",
+                "qualifier": "LATEST",
+                "trigger_config": json.dumps(config),
+            },
+        )
+
+    def _timer(self, doc: TerraformDoc, name: str, fn_res: str, i: int, ev: Any) -> None:
+        expr = sched.every_expression(ev) if ev.rate else "0 " + sched.named_cron5(ev)
+        if ev.cron and ev.timezone and ev.timezone != "UTC":
+            expr = f"CRON_TZ={ev.timezone} {expr}"
+        config = {
+            "cronExpression": expr,
+            "enable": bool(ev.enabled),
+            "payload": json.dumps(envelope("schedule", ev.input, source="alibaba.timer")),
+        }
+        doc.resource(
+            TRIGGER,
+            f"{name}-timer-{i}",
+            {
+                "function_name": ref(fn_res, "function_name"),
+                "trigger_name": (ev.name or f"timer-{i}")[:128],
+                "trigger_type": "timer",
+                "qualifier": "LATEST",
+                "trigger_config": escape(json.dumps(config)),
+            },
+        )
+
+    def _oss(
+        self,
+        doc: TerraformDoc,
+        ctx: RenderContext,
+        name: str,
+        fn_res: str,
+        ev: Any,
+        role: Optional[str],
+        account: Optional[str],
+    ) -> None:
+        label = f"b-{ev.bucket}"
+        if not ev.existing and not doc.has_resource("alicloud_oss_bucket", label):
+            doc.resource("alicloud_oss_bucket", label, {"bucket": ev.bucket, "tags": ctx.tags()})
+        events = [{"created": "oss:ObjectCreated:*", "deleted": "oss:ObjectRemoved:*"}[e] for e in ev.events]
+        config = {"events": events, "filter": {"key": {"prefix": ev.prefix or "", "suffix": ev.suffix or ""}}}
+        body: Dict[str, Any] = {
+            "function_name": ref(fn_res, "function_name"),
+            "trigger_name": f"oss-{tf_id(ev.bucket)}"[:128],
+            "trigger_type": "oss",
+            "qualifier": "LATEST",
+            "invocation_role": role,
+            "source_arn": f"acs:oss:{ctx.region}:{ref(str(account), 'id')}:{ev.bucket}",
+            "trigger_config": json.dumps(config),
+        }
+        if not ev.existing:
+            body["depends_on"] = [f"alicloud_oss_bucket.{tf_id(label)}"]
+        doc.resource(TRIGGER, f"{name}-oss-{ev.bucket}", body)
+
+    def _mns_topic(
+        self,
+        doc: TerraformDoc,
+        ctx: RenderContext,
+        name: str,
+        fn_res: str,
+        ev: Any,
+        role: Optional[str],
+        account: Optional[str],
+    ) -> None:
+        label = f"t-{ev.name}"
+        if not ev.existing and not doc.has_resource("alicloud_message_service_topic", label):
+            doc.resource("alicloud_message_service_topic", label, {"topic_name": ev.name, "tags": ctx.tags()})
+        config: Dict[str, Any] = {"notifyContentFormat": "JSON", "notifyStrategy": "BACKOFF_RETRY"}
+        if ev.filter and isinstance(ev.filter.get("tag"), str):
+            config["filterTag"] = ev.filter["tag"]
+        body: Dict[str, Any] = {
+            "function_name": ref(fn_res, "function_name"),
+            "trigger_name": f"mns-{tf_id(ev.name)}"[:128],
+            "trigger_type": "mns_topic",
+            "qualifier": "LATEST",
+            "invocation_role": role,
+            "source_arn": f"acs:mns:{ctx.region}:{ref(str(account), 'id')}:/topics/{ev.name}",
+            "trigger_config": json.dumps(config),
+        }
+        if not ev.existing:
+            body["depends_on"] = [f"alicloud_message_service_topic.{tf_id(label)}"]
+        doc.resource(TRIGGER, f"{name}-mns-{ev.name}", body)