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

py_serverless_kit/providers/huawei.py

@@ -0,0 +1,292 @@
+"""Huawei Cloud: FunctionGraph + dedicated API Gateway + timer / OBS / SMN triggers."""
+
+from __future__ import annotations
+
+import json
+import re
+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 = "huaweicloud_fgs_function"
+TRIGGER = "huaweicloud_fgs_trigger"
+_AUTH = {"none": "NONE", "iam": "IAM", "key": "APP"}
+
+
+def quartz_cron(ev: Any) -> str:
+    """FunctionGraph cron: ``sec min hour dom month dow`` where dom or dow must be ``?``."""
+    minute, hour, dom, month, dow = sched.named_cron5(ev).split()
+    if dow == "*":
+        dow = "?"
+    elif dom == "*":
+        dom = "?"
+    return f"0 {minute} {hour} {dom} {month} {dow}"
+
+
+def rate_expression(ev: Any) -> str:
+    value, unit = sched.parse_rate(ev.rate or "")
+    return f"{value}{unit[0]}"
+
+
+def _gateway_path(path: str) -> tuple[str, str]:
+    segments = [s for s in path.split("/") if s]
+    if segments and segments[-1].endswith("+}"):
+        return "/" + "/".join(segments[:-1]), "Prefix"
+    return "/" + "/".join(segments), "Exact"
+
+
+class HuaweiProvider(Provider):
+    name = "huawei"
+    display_name = "Huawei Cloud FunctionGraph"
+    tier = "beta"
+    terraform_source = "huaweicloud/huaweicloud"
+    terraform_version = ">= 1.60.0"
+    terraform_local_name = "huaweicloud"
+    default_region = "cn-north-4"
+    capabilities = frozenset({HTTP, SCHEDULE, STORAGE, TOPIC})
+    max_name_length = 60
+    name_pattern = r"[^a-z0-9_-]"
+    runtimes = {"python3.9": "Python3.9", "python3.10": "Python3.10", "python3.12": "Python3.12"}
+    vendor_dependencies = True
+    max_timeout = 900
+    notes = (
+        "HTTP needs a dedicated APIG instance (options.apig_instance_id); timers, OBS and SMN 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. FunctionGraph handler: index.handler\n"
+                "from py_serverless_kit.runtime.adapters.huawei import handler  # noqa: F401\n"
+            )
+        }
+
+    def provider_block(self, ctx: RenderContext) -> Dict[str, Any]:
+        block: Dict[str, Any] = {"region": ctx.region}
+        for key in ("profile", "enterprise_project_id"):
+            if ctx.opt(key):
+                block[key] = ctx.opt(key)
+        return block
+
+    def physical_name(self, service: str, stage: str, logical: str) -> str:
+        name = super().physical_name(service, stage, logical)
+        return name if re.match(r"[a-z]", name) else f"f{name}"[: self.max_name_length]
+
+    def extra_validation(self, config: ServiceConfig) -> List[Issue]:
+        issues = []
+        has_http = any(fn.events_of("http") for fn in config.functions.values())
+        if has_http and not config.provider.options.get("apig_instance_id"):
+            issues.append(
+                Issue(
+                    "error",
+                    "HTTP events need a dedicated API Gateway instance: set provider.options.apig_instance_id",
+                    "provider.options",
+                )
+            )
+        if config.provider.iam.statements:
+            issues.append(
+                Issue(
+                    "warning",
+                    "iam.statements are ignored on Huawei; set iam.role to an IAM agency name",
+                    "provider.iam",
+                )
+            )
+        for name, fn in config.functions.items():
+            for ev in fn.events_of("http"):
+                if ev.auth not in _AUTH:
+                    issues.append(
+                        Issue(
+                            "error",
+                            f"http auth `{ev.auth}` is not supported on Huawei (none, iam, key)",
+                            f"functions.{name}",
+                        )
+                    )
+        return issues
+
+    # ------------------------------------------------------------------ render
+    def render_resources(self, doc: TerraformDoc, ctx: RenderContext) -> None:
+        cfg = ctx.config
+        fn_out: Dict[str, Dict[str, Any]] = {}
+        gateway: Optional[Dict[str, str]] = None
+        for name, fn in ctx.function_items():
+            res = self._function(doc, ctx, name, fn)
+            out: Dict[str, Any] = {
+                "id": ref(res, "name"),
+                "arn": ref(res, "urn"),
+                "console": f"https://console.huaweicloud.com/functiongraph/?region={ctx.region}#/serverless/functions",
+            }
+            http_events = fn.events_of("http")
+            if http_events:
+                gateway = gateway or self._gateway(doc, ctx)
+                self._apis(doc, ctx, gateway, name, res, fn, http_events)
+                out["base_url"] = gateway["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._obs(doc, ctx, name, res, ev)
+            for ev in fn.events_of("topic"):
+                self._smn(doc, ctx, name, res, ev)
+            fn_out[name] = out
+
+        wf_out = {n: {"id": ref(FUNCTION, tf_id(f"{n}-orchestrator"), "name")} for n in sorted(cfg.workflows)}
+        doc.output(
+            "pskit",
+            {"functions": fn_out, "workflows": wf_out, "endpoint": gateway["url"] if gateway else None},
+            description="py-serverless-kit deployment summary",
+        )
+
+    # ------------------------------------------------------------------ pieces
+    def _function(self, doc: TerraformDoc, ctx: RenderContext, name: str, fn: FunctionConfig) -> str:
+        cfg = ctx.config
+        body: Dict[str, Any] = {
+            "name": ctx.physical_name(name),
+            "app": ctx.opt("app", "default"),
+            "description": fn.description[:512],
+            "handler": "index.handler",
+            "runtime": self.runtime_id(cfg.runtime_of(fn)),
+            "memory_size": cfg.memory_of(fn),
+            "timeout": cfg.timeout_of(fn),
+            "code_type": "zip",
+            "code_filename": "artifact.zip",
+            "func_code": '${filebase64("${path.module}/artifact.zip")}',
+            "user_data": escape(json.dumps(ctx.environment(name, fn), sort_keys=True)),
+            "tags": ctx.tags(fn),
+        }
+        agency = fn.iam.role or cfg.provider.iam.role
+        if agency:
+            body["agency"] = agency
+        if fn.concurrency:
+            body["concurrency_num"] = fn.concurrency
+        body.update(fn.options)  # escape hatch: vpc_id, network_id, depend_list, ...
+        return doc.resource(FUNCTION, name, body)
+
+    def _gateway(self, doc: TerraformDoc, ctx: RenderContext) -> Dict[str, str]:
+        instance = ctx.opt("apig_instance_id")
+        group = doc.resource(
+            "huaweicloud_apig_group",
+            "http",
+            {
+                "instance_id": instance,
+                "name": re.sub(r"[^A-Za-z0-9_]", "_", ctx.prefix)[:64],
+                "description": f"py-serverless-kit {ctx.service} ({ctx.stage})",
+                "domain_access_enabled": True,
+            },
+        )
+        env = doc.resource(
+            "huaweicloud_apig_environment",
+            "stage",
+            {"instance_id": instance, "name": ("pskit_" + re.sub(r"[^A-Za-z0-9_]", "_", ctx.stage))[:64]},
+        )
+        groups = doc.data("huaweicloud_apig_groups", "http", {"instance_id": instance, "group_id": ref(group, "id")})
+        return {
+            "instance": instance,
+            "group": group,
+            "env": env,
+            "url": "https://" + ref(groups, "groups[0].sl_domain"),
+        }
+
+    def _apis(
+        self,
+        doc: TerraformDoc,
+        ctx: RenderContext,
+        gw: Dict[str, str],
+        name: str,
+        fn_res: str,
+        fn: FunctionConfig,
+        events: List[Any],
+    ) -> None:
+        for i, ev in enumerate(events):
+            path, matching = _gateway_path(ev.path)
+            body: Dict[str, Any] = {
+                "instance_id": gw["instance"],
+                "group_id": ref(gw["group"], "id"),
+                "name": re.sub(r"[^A-Za-z0-9_]", "_", f"{name}_{i}")[:64],
+                "type": "Public",
+                "request_protocol": "BOTH",
+                "request_method": ev.method,
+                "request_path": path,
+                "matching": matching,
+                "security_authentication": _AUTH.get(ev.auth, "NONE"),
+                "cors": ev.cors_config is not None,
+                "description": f"{ev.method} {ev.path} -> {name}",
+                "func_graph": {
+                    "function_urn": ref(fn_res, "urn"),
+                    "invocation_type": "sync",
+                    "network_type": "NON-VPC",
+                    "timeout": min(ctx.config.timeout_of(fn) * 1000, 600000),
+                },
+            }
+            params = re.findall(r"\{([A-Za-z_]\w*)\}", path)
+            if params:
+                body["request_params"] = [
+                    {"name": p, "location": "PATH", "type": "STRING", "required": True, "passthrough": True}
+                    for p in params
+                ]
+            api = doc.resource("huaweicloud_apig_api", f"{name}-{i}", body)
+            doc.resource(
+                "huaweicloud_apig_api_publishment",
+                f"{name}-{i}",
+                {"instance_id": gw["instance"], "api_id": ref(api, "id"), "env_id": ref(gw["env"], "id")},
+            )
+
+    def _timer(self, doc: TerraformDoc, name: str, fn_res: str, i: int, ev: Any) -> None:
+        timer: Dict[str, Any] = {
+            "name": re.sub(r"[^A-Za-z0-9_-]", "-", ev.name or f"timer-{i}")[:64],
+            "schedule_type": "Rate" if ev.rate else "Cron",
+            "schedule": rate_expression(ev) if ev.rate else quartz_cron(ev),
+            "additional_information": escape(json.dumps(envelope("schedule", ev.input, source="huawei.timer"))),
+        }
+        doc.resource(
+            TRIGGER,
+            f"{name}-timer-{i}",
+            {
+                "function_urn": ref(fn_res, "urn"),
+                "type": "TIMER",
+                "status": "ACTIVE" if ev.enabled else "DISABLED",
+                "timer": timer,
+            },
+        )
+
+    def _obs(self, doc: TerraformDoc, ctx: RenderContext, name: str, fn_res: str, ev: Any) -> None:
+        label = f"b-{ev.bucket}"
+        body: Dict[str, Any] = {
+            "function_urn": ref(fn_res, "urn"),
+            "type": "OBS",
+            "status": "ACTIVE",
+            "obs": {
+                "bucket_name": ev.bucket,
+                "event_notification_name": re.sub(r"[^A-Za-z0-9_-]", "-", f"pskit-{name}")[:64],
+                "events": [{"created": "ObjectCreated", "deleted": "ObjectRemoved"}[e] for e in ev.events],
+            },
+        }
+        if ev.prefix:
+            body["obs"]["prefix"] = ev.prefix
+        if ev.suffix:
+            body["obs"]["suffix"] = ev.suffix
+        if not ev.existing:
+            if not doc.has_resource("huaweicloud_obs_bucket", label):
+                doc.resource(
+                    "huaweicloud_obs_bucket", label, {"bucket": ev.bucket, "acl": "private", "tags": ctx.tags()}
+                )
+            body["depends_on"] = [f"huaweicloud_obs_bucket.{tf_id(label)}"]
+        doc.resource(TRIGGER, f"{name}-obs-{ev.bucket}", body)
+
+    def _smn(self, doc: TerraformDoc, ctx: RenderContext, name: str, fn_res: str, ev: Any) -> None:
+        label = f"t-{ev.name}"
+        if ev.existing:
+            topic_urn = ref(doc.data("huaweicloud_smn_topics", label, {"name": ev.name}), "topics[0].topic_urn")
+        else:
+            if not doc.has_resource("huaweicloud_smn_topic", label):
+                doc.resource("huaweicloud_smn_topic", label, {"name": ev.name, "tags": ctx.tags()})
+            topic_urn = ref("huaweicloud_smn_topic", tf_id(label), "topic_urn")
+        doc.resource(
+            TRIGGER,
+            f"{name}-smn-{ev.name}",
+            {"function_urn": ref(fn_res, "urn"), "type": "SMN", "status": "ACTIVE", "smn": {"topic_urn": topic_urn}},
+        )

py_serverless_kit/providers/ibm.py

@@ -0,0 +1,132 @@
+"""IBM Cloud: Code Engine functions (HTTP endpoints)."""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Tuple
+
+from ..config.schema import ServiceConfig
+from .base import HTTP, Issue, Provider, RenderContext
+from .terraform_doc import TerraformDoc, escape, ref, tf_id
+
+FUNCTION = "ibm_code_engine_function"
+# Code Engine function CPU / memory combinations (vCPU, memory).
+_SIZES: Tuple[Tuple[str, str, int], ...] = (
+    ("0.125", "0.5G", 512),
+    ("0.25", "1G", 1024),
+    ("0.5", "2G", 2048),
+    ("1", "4G", 4096),
+)
+
+
+def size_for(memory_mb: int) -> Tuple[str, str]:
+    for cpu, mem, mb in _SIZES:
+        if memory_mb <= mb:
+            return cpu, mem
+    return _SIZES[-1][0], _SIZES[-1][1]
+
+
+class IbmProvider(Provider):
+    name = "ibm"
+    display_name = "IBM Cloud Code Engine"
+    tier = "beta"
+    terraform_source = "IBM-Cloud/ibm"
+    terraform_version = ">= 1.70"
+    default_region = "us-south"
+    capabilities = frozenset({HTTP})
+    max_name_length = 63
+    runtimes = {"python3.11": "python-3.11"}
+    vendor_dependencies = True
+    max_timeout = 120
+    notes = (
+        "Every Code Engine function gets a public HTTPS endpoint; routes are matched by the pskit runtime. "
+        "No schedule/queue/storage/topic triggers (the Terraform provider has no function event "
+        "subscriptions). Code is uploaded inline as a base64 data URL, so keep bundles small or set "
+        "options.code_reference to a code bundle image. Auth: set IC_API_KEY."
+    )
+
+    # ------------------------------------------------------------------ bundle
+    def shim_files(self, config: ServiceConfig) -> Dict[str, str]:
+        return {
+            "__main__.py": (
+                "# Generated by py-serverless-kit. Code Engine entrypoint: main(params)\n"
+                "from py_serverless_kit.runtime.adapters.ibm import main  # noqa: F401\n"
+            )
+        }
+
+    def provider_block(self, ctx: RenderContext) -> Dict[str, Any]:
+        block: Dict[str, Any] = {"region": ctx.region}
+        if ctx.opt("resource_group"):
+            block["resource_group"] = ctx.opt("resource_group")
+        return block
+
+    def extra_validation(self, config: ServiceConfig) -> List[Issue]:
+        issues: List[Issue] = []
+        for name, fn in config.functions.items():
+            for ev in fn.events_of("http"):
+                if ev.auth != "none":
+                    issues.append(
+                        Issue(
+                            "error",
+                            f"auth `{ev.auth}` is not supported on Code Engine functions; "
+                            "validate tokens in the handler",
+                            f"functions.{name}",
+                        )
+                    )
+            if config.memory_of(fn) > _SIZES[-1][2]:
+                issues.append(
+                    Issue("error", "Code Engine functions support at most 4096 MB", f"functions.{name}.memory")
+                )
+        return issues
+
+    # ------------------------------------------------------------------ render
+    def _project(self, doc: TerraformDoc, ctx: RenderContext) -> str:
+        if ctx.opt("project_id"):
+            return str(ctx.opt("project_id"))
+        body: Dict[str, Any] = {"name": ctx.prefix}
+        if ctx.opt("resource_group_id"):
+            body["resource_group_id"] = ctx.opt("resource_group_id")
+        return ref(doc.resource("ibm_code_engine_project", "project", body), "project_id")
+
+    def render_resources(self, doc: TerraformDoc, ctx: RenderContext) -> None:
+        cfg = ctx.config
+        project = self._project(doc, ctx)
+        code_ref = ctx.opt("code_reference") or 'data:text/plain;base64,${filebase64("${path.module}/artifact.zip")}'
+        fn_out: Dict[str, Dict[str, Any]] = {}
+        endpoint: Optional[str] = None
+        for name, fn in ctx.function_items():
+            cpu, mem = size_for(cfg.memory_of(fn))
+            env = [
+                {"type": "literal", "name": k, "value": escape(v)} for k, v in sorted(ctx.environment(name, fn).items())
+            ]
+            body: Dict[str, Any] = {
+                "project_id": project,
+                "name": ctx.physical_name(name),
+                "runtime": self.runtime_id(cfg.runtime_of(fn)),
+                "code_reference": code_ref,
+                "code_binary": not ctx.opt("code_reference"),
+                "code_main": "main",
+                "scale_cpu_limit": cpu,
+                "scale_memory_limit": mem,
+                "scale_max_execution_time": cfg.timeout_of(fn),
+                "managed_domain_mappings": fn.options.get("visibility", ctx.opt("visibility", "local_public")),
+                "run_env_variables": env,
+            }
+            if fn.concurrency:
+                body["scale_concurrency"] = fn.concurrency
+            body.update({k: v for k, v in fn.options.items() if k != "visibility"})
+            res = doc.resource(FUNCTION, name, body)
+            out: Dict[str, Any] = {
+                "id": ref(res, "function_id"),
+                "url": ref(res, "endpoint"),
+                "console": f"https://cloud.ibm.com/codeengine/project/{ctx.region}/{project}/functions",
+            }
+            if fn.events_of("http"):
+                out["base_url"] = ref(res, "endpoint")
+                endpoint = endpoint or ref(res, "endpoint")
+            fn_out[name] = out
+        wf_out = {n: {"id": ref(FUNCTION, tf_id(f"{n}-orchestrator"), "endpoint")} for n in cfg.workflows}
+        doc.output(
+            "pskit",
+            {"functions": fn_out, "workflows": wf_out, "endpoint": endpoint},
+            description="py-serverless-kit deployment summary",
+        )