faas-gitops 0.2.1__tar.gz

faas_gitops-0.2.1/MANIFEST.in

@@ -0,0 +1 @@
+exclude README.md

faas_gitops-0.2.1/PKG-INFO

@@ -0,0 +1,12 @@
+Metadata-Version: 2.4
+Name: faas-gitops
+Version: 0.2.1
+Summary: Declarative GitOps for FaaS
+Requires-Python: >=3.12
+Requires-Dist: aiofiles>=23.0
+Requires-Dist: bizy-deploy>=0.5.4
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: tqdm>=4.66.0
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-asyncio>=0.23; extra == "test"

faas_gitops-0.2.1/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "faas-gitops"
+version = "0.2.1"
+description = "Declarative GitOps for FaaS"
+requires-python = ">=3.12"
+dependencies = [
+    "aiofiles>=23.0",
+    "bizy-deploy>=0.5.4",
+    "pyyaml>=6.0",
+    "tqdm>=4.66.0",
+]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=7.0",
+    "pytest-asyncio>=0.23",
+]
+
+[project.scripts]
+faas-gitops = "faas_gitops.cli.app:main"
+
+[tool.pytest.ini_options]
+asyncio_mode = "auto"
+
+[tool.setuptools.packages.find]
+where = ["src"]

faas_gitops-0.2.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

faas_gitops-0.2.1/src/faas_gitops/adapters/bizy_function_provider.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+from bizy_deploy import AsyncFaaSActionProvider
+
+
+class BizyFunctionProvider:
+    """FaaS function operations via bizy-deploy SDK.
+
+    Implements FaaSFunctionProvider protocol.
+    Delegates to AsyncFaaSActionProvider from bizy_deploy.
+    """
+
+    def __init__(self, provider: AsyncFaaSActionProvider) -> None:
+        self._p = provider
+
+    async def list_functions(self) -> list[dict]:
+        result = await self._p.list_functions()
+        return [i.to_dict() for i in result.data.data if i is not None]
+
+    async def get_latest_definition(self, func_id: str) -> dict | None:
+        result = await self._p.get_latest_function_definition(function_id=func_id)
+        return result.to_dict() if result else None
+
+    async def push_definition(self, func_id: str, data: dict, comment: str = "") -> str:
+        return await self._p.create_function_definition(merged_def=data, function_id=func_id)
+
+    async def update_function_meta(self, func_id: str, meta: dict) -> None:
+        await self._p.update_function(
+            function_id=func_id,
+            name=meta.get("functionName"),
+            tags=meta.get("tags"),
+        )

faas_gitops-0.2.1/src/faas_gitops/adapters/bizy_template_provider.py

@@ -0,0 +1,31 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from bizy_deploy import AsyncFaaSActionProvider
+
+
+class BizyTemplateProvider:
+
+    def __init__(self, provider: AsyncFaaSActionProvider) -> None:
+        self._p = provider
+
+    async def list_templates(self) -> list[dict]:
+        priv = await self._p.list_private_templates()
+        pub = await self._p.list_published_templates()
+        items = [i.to_dict() for i in (priv.data.data + pub.data.data) if i is not None]
+        return items
+
+    async def get_template(self, org_id: str, template_id: str, dest: Path) -> None:
+        await self._p.get_template(org_id=org_id, template_id=template_id, output=str(dest))
+
+    async def get_template_content(self, org_id: str, template_name: str) -> str:
+        path = await self._p.get_template(org_id=org_id, template_id=template_name)
+        return Path(path).read_text()
+
+    async def update_template(self, org_id: str, template_id: str, yaml_content: str) -> dict:
+        files = {"file": ("template.yaml", yaml_content, "application/x-yaml")}
+        return await self._p.update_template(name=template_id, files=files)
+
+    async def render_template_draft(self, *, file: str, use_cache: bool = False, output: str | None = None) -> dict:
+        return await self._p.render_template_draft_v2(file=file, use_cache=use_cache, output=output)

faas_gitops-0.2.1/src/faas_gitops/adapters/git_cli_gateway.py

@@ -0,0 +1,107 @@
+from __future__ import annotations
+
+import asyncio
+from pathlib import Path
+from loguru import logger
+from faas_gitops.protocols.git_gateway import PushResult
+
+
+async def _git(*args: str, cwd: Path | None = None, check: bool = True) -> str:
+    cmd = ["git", *args]
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, cwd=cwd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    if check and proc.returncode != 0:
+        raise RuntimeError(f"git {' '.join(args)} failed: {stderr.decode()}")
+    return stdout.decode().strip()
+
+
+async def _gh(*args: str, cwd: Path | None = None, check: bool = True) -> str:
+    cmd = ["gh", *args]
+    proc = await asyncio.create_subprocess_exec(
+        *cmd, cwd=cwd,
+        stdout=asyncio.subprocess.PIPE,
+        stderr=asyncio.subprocess.PIPE,
+    )
+    stdout, stderr = await proc.communicate()
+    if check and proc.returncode != 0:
+        raise RuntimeError(f"gh {' '.join(args)} failed: {stderr.decode()}")
+    return stdout.decode().strip()
+
+
+class GitCliGateway:
+
+    def __init__(self, clone_root: Path) -> None:
+        self._root = clone_root
+        self._root.mkdir(parents=True, exist_ok=True)
+        logger.info(f"GitCliGateway init: clone_root={self._root}")
+
+    async def clone_repo(self, repo_slug: str) -> Path:
+        dest = self._root / repo_slug.split("/")[-1]
+        if dest.exists():
+            logger.info(f"pull existing repo: {dest.name}")
+            await _git("pull", cwd=dest, check=False)
+        else:
+            logger.info(f"gh repo clone {repo_slug}")
+            await _gh("repo", "clone", repo_slug, str(dest))
+        return dest
+
+    async def prepare_branch(self, repo_path: Path, branch: str, force: bool = False) -> None:
+        await _git("fetch", "origin", cwd=repo_path)
+        remote_exists = await _git("rev-parse", "--verify", f"origin/{branch}", cwd=repo_path, check=False)
+        if force or not remote_exists:
+            await _git("checkout", "main", cwd=repo_path)
+            await _git("pull", cwd=repo_path, check=False)
+            if force:
+                await _git("branch", "-D", branch, cwd=repo_path, check=False)
+            await _git("checkout", "-B", branch, cwd=repo_path)
+        else:
+            await _git("checkout", branch, cwd=repo_path, check=False) or await _git("checkout", "-B", branch, cwd=repo_path)
+            await _git("reset", "--hard", f"origin/{branch}", cwd=repo_path)
+
+    async def current_branch(self, repo_path: Path) -> str:
+        return await _git("rev-parse", "--abbrev-ref", "HEAD", cwd=repo_path)
+
+    async def checkout(self, repo_path: Path, ref: str) -> None:
+        await _git("checkout", ref, cwd=repo_path)
+
+    async def commit_and_push(
+        self,
+        repo_path: Path,
+        prefix: str,
+        msg: str,
+        branch: str,
+        *,
+        force: bool = False,
+        create_pr: bool = False,
+    ) -> PushResult:
+        await _git("add", prefix, cwd=repo_path)
+        proc = await asyncio.create_subprocess_exec(
+            "git", "diff", "--cached", "--quiet",
+            cwd=repo_path,
+            stdout=asyncio.subprocess.PIPE,
+            stderr=asyncio.subprocess.PIPE,
+        )
+        await proc.communicate()
+        if proc.returncode == 0:
+            return PushResult(pushed=False)
+        await _git("commit", "-m", msg, cwd=repo_path)
+        if not force:
+            await _git("pull", "--rebase", "origin", branch, cwd=repo_path, check=False)
+        await _git("push", "origin", branch, *(["--force"] if force else []), cwd=repo_path)
+        if create_pr:
+            proc = await asyncio.create_subprocess_exec(
+                "gh", "pr", "create", "--fill", "--base", "main", "--head", branch,
+                cwd=repo_path,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+            )
+            stdout, stderr = await proc.communicate()
+            out = stdout.decode().strip()
+            err = stderr.decode().strip()
+            url = out or next((l for l in err.splitlines() if l.startswith("http")), None)
+            return PushResult(pushed=True, url=url)
+        return PushResult(pushed=True)

faas_gitops-0.2.1/src/faas_gitops/cli/app.py

@@ -0,0 +1,112 @@
+from __future__ import annotations
+
+import asyncio
+import tempfile
+from contextlib import AsyncExitStack
+from pathlib import Path
+
+from bizy_deploy import AsyncFaaSActionProvider
+from loguru import logger
+
+from faas_gitops.adapters.bizy_function_provider import BizyFunctionProvider
+from faas_gitops.adapters.bizy_template_provider import BizyTemplateProvider
+from faas_gitops.adapters.git_cli_gateway import GitCliGateway
+from faas_gitops.cli.parser import build_parser
+from faas_gitops.cli.presenters import print_apply_report, print_drift_report
+from faas_gitops.config import load_settings
+from faas_gitops.models import ApplyResult
+from faas_gitops.usecases.apply_function_changes import ApplyFunctionChanges
+from faas_gitops.usecases.apply_template_changes import ApplyTemplateChanges
+from faas_gitops.usecases.detect_function_drift import DetectFunctionDrift
+from faas_gitops.usecases.detect_template_drift import DetectTemplateDrift
+from faas_gitops.usecases.render_definitions import render_definitions
+from faas_gitops.usecases.sync_functions import SyncFunctions
+from faas_gitops.usecases.sync_templates import SyncTemplates
+
+
+def _make_git() -> GitCliGateway:
+    return GitCliGateway(Path(tempfile.mkdtemp(prefix="faas-gitops-")))
+
+
+async def _make_faas(stack: AsyncExitStack) -> AsyncFaaSActionProvider:
+    faas = AsyncFaaSActionProvider()
+    stack.push_async_callback(faas.client.close)
+    return faas
+
+
+async def async_main() -> int:
+    settings = load_settings()
+    parser = build_parser(settings)
+    args = parser.parse_args()
+    if not args.command:
+        parser.print_help()
+        return 1
+
+    repo_slug: str = args.repo
+
+    async with AsyncExitStack() as stack:
+        if args.command == "sync-templates":
+            faas = await _make_faas(stack)
+            provider = BizyTemplateProvider(faas)
+            git = _make_git()
+            push = await SyncTemplates(provider, git, settings).run(await git.clone_repo(repo_slug))
+            logger.info(push.url if push.pushed and push.url else ("branch pushed" if push.pushed else "no changes"))
+            return 0
+
+        if args.command == "sync-functions":
+            faas = await _make_faas(stack)
+            provider = BizyFunctionProvider(faas)
+            tpl_provider = BizyTemplateProvider(faas)
+            git = _make_git()
+            repo_path = await git.clone_repo(repo_slug)
+            push = await SyncFunctions(provider, git, settings, tpl_provider=tpl_provider, branch=args.branch).run(repo_path)
+            logger.info(push.url if push.pushed and push.url else ("branch pushed" if push.pushed else "no changes"))
+            return 0
+
+        if args.command == "render-definitions":
+            faas = await _make_faas(stack)
+            tpl_provider = BizyTemplateProvider(faas)
+            git = _make_git()
+            repo_path = await git.clone_repo(repo_slug)
+            n = await render_definitions(tpl_provider, repo_path, branch=args.branch, git=git, max_workers=settings.max_workers)
+            logger.info(f"render-definitions: {n} file(s) written")
+            return 0
+
+        if args.command == "detect-template-changes":
+            git = _make_git()
+            repo_path = await git.clone_repo(repo_slug)
+            return print_drift_report(await DetectTemplateDrift().run(repo_path))
+
+        if args.command == "detect-function-changes":
+            git = _make_git()
+            repo_path = await git.clone_repo(repo_slug)
+            return print_drift_report(await DetectFunctionDrift(settings).run(repo_path))
+
+        if args.command == "apply-template-changes":
+            faas = await _make_faas(stack)
+            git = _make_git()
+            repo_path = await git.clone_repo(repo_slug)
+            result = await ApplyTemplateChanges(BizyTemplateProvider(faas)).run(
+                repo_path, dry_run=getattr(args, "dry_run", False),
+            )
+            return print_apply_report(result, getattr(args, "dry_run", False))
+
+        if args.command == "apply-function-changes":
+            faas = await _make_faas(stack)
+            git = _make_git()
+            repo_path = await git.clone_repo(repo_slug)
+            result = await ApplyFunctionChanges(BizyFunctionProvider(faas), settings).run(
+                repo_path, dry_run=getattr(args, "dry_run", False), repo_slug=repo_slug,
+            )
+            return print_apply_report(result, getattr(args, "dry_run", False))
+
+    logger.warning(f"unknown command: {args.command}")
+    return 1
+
+
+def main() -> int:
+    return asyncio.run(async_main())
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

faas_gitops-0.2.1/src/faas_gitops/cli/parser.py

@@ -0,0 +1,41 @@
+from __future__ import annotations
+
+import argparse
+
+from faas_gitops.config import Settings
+
+
+def build_parser(settings: Settings) -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(prog="faas-gitops")
+    sub = parser.add_subparsers(dest="command")
+
+    def _add_repo(p: argparse.ArgumentParser) -> None:
+        p.add_argument("--repo", default=settings.default_repo)
+
+    p = sub.add_parser("sync-templates")
+    p.add_argument("--branch", default="sync/faas-templates")
+    _add_repo(p)
+
+    p = sub.add_parser("sync-functions")
+    p.add_argument("--branch", default="sync/faas-functions")
+    _add_repo(p)
+    
+    p = sub.add_parser("render-definitions")
+    p.add_argument("--branch", default=None)
+    _add_repo(p)
+
+    p = sub.add_parser("detect-template-changes")
+    _add_repo(p)
+
+    p = sub.add_parser("detect-function-changes")
+    _add_repo(p)
+
+    p = sub.add_parser("apply-template-changes")
+    p.add_argument("--dry-run", action="store_true")
+    _add_repo(p)
+
+    p = sub.add_parser("apply-function-changes")
+    p.add_argument("--dry-run", action="store_true")
+    _add_repo(p)
+
+    return parser

faas_gitops-0.2.1/src/faas_gitops/cli/presenters.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+from loguru import logger
+
+from faas_gitops.models import ApplyResult, DriftResult
+
+
+def print_drift_report(result: DriftResult) -> int:
+    has_drift = bool(result.drifted or result.missing_in_git or result.missing_in_faas)
+    logger.info(f"drifted={len(result.drifted)} missing_git={len(result.missing_in_git)} missing_faas={len(result.missing_in_faas)}")
+    for n in result.drifted:
+        logger.info(f"  Δ {n}")
+    for n in result.missing_in_git:
+        logger.info(f"  + {n}")
+    for n in result.missing_in_faas:
+        logger.info(f"  - {n}")
+    if result.diff_text:
+        logger.info(result.diff_text)
+    return 1 if has_drift else 0
+
+
+def print_apply_report(result: ApplyResult, dry_run: bool = False) -> int:
+    logger.info(f"applied={len(result.applied)} unchanged={len(result.unchanged)} skipped={len(result.skipped)}{' (dry-run)' if dry_run else ''}")
+    for n in result.applied:
+        logger.info(f"  ✓ {n}")
+    for n in result.skipped:
+        logger.info(f"  - {n}")
+    for name, err in result.failed:
+        logger.warning(f"  ! {name}: {err}")
+    return 1 if result.failed else 0

faas_gitops-0.2.1/src/faas_gitops/config.py

@@ -0,0 +1,30 @@
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Settings:
+    default_repo: str = "siliconflow/faas-gitops-test"
+    scoped_templates: set[str] | None = None
+    scoped_template_tags: set[str] | None = None
+    scoped_functions: set[str] | None = None
+    scoped_function_tags: set[str] | None = None
+    max_workers: int = 8
+
+
+def _csv_set(key: str) -> set[str] | None:
+    val = os.getenv(key)
+    return {s for s in val.split(",") if s} if val else None
+
+
+def load_settings() -> Settings:
+    return Settings(
+        default_repo=os.getenv("DEFAULT_REPO", Settings.default_repo),
+        scoped_templates=_csv_set("SCOPED_TEMPLATES"),
+        scoped_template_tags=_csv_set("SCOPED_TEMPLATE_TAGS"),
+        scoped_functions=_csv_set("SCOPED_FUNCTIONS"),
+        scoped_function_tags=_csv_set("SCOPED_FUNCTION_TAGS"),
+        max_workers=int(os.getenv("MAX_WORKERS", "128")),
+    )

faas_gitops-0.2.1/src/faas_gitops/filtering.py

@@ -0,0 +1,9 @@
+from __future__ import annotations
+
+
+def match_scope(item_id: str, tags: list[str], id_set: set[str] | None, tag_set: set[str] | None) -> bool:
+    if id_set is None and tag_set is None:
+        return True
+    by_id = id_set is not None and item_id in id_set
+    by_tag = tag_set is not None and tags is not None and bool(set(tags) & tag_set)
+    return by_id or by_tag

faas_gitops-0.2.1/src/faas_gitops/infra/yaml_utils.py

@@ -0,0 +1,17 @@
+from __future__ import annotations
+
+import yaml
+from bizy_deploy.core.utils import standardize_faas_yaml
+
+
+def load_yaml(text: str | None) -> dict | None:
+    if not text:
+        return None
+    return yaml.safe_load(text)
+
+
+def dump_faas_yaml(data: dict | str) -> str:
+    if isinstance(data, dict):
+        data = yaml.dump(data, sort_keys=False, allow_unicode=True)
+    assert isinstance(data, str)
+    return standardize_faas_yaml(data)

faas_gitops-0.2.1/src/faas_gitops/layout.py

@@ -0,0 +1,12 @@
+"""File layout conventions."""
+
+TEMPLATE_DIR = "templates"
+TEMPLATE_FILES = ("info.yaml", "template.jinja", "schema.yaml")
+TEMPLATE_PRIMARY = "info.yaml"
+
+FUNCTION_DIR = "functions"
+FUNCTION_META = "meta.yaml"
+FUNCTION_BASE = "base.yaml"
+FUNCTION_DEFINITION = "definition.yaml"
+FUNCTION_FILES = (FUNCTION_META, FUNCTION_BASE, FUNCTION_DEFINITION)
+FUNCTION_RENDERED = "rendered.yaml"

faas_gitops-0.2.1/src/faas_gitops/models.py

@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict
+import tempfile
+
+import yaml
+
+from faas_gitops.infra.yaml_utils import dump_faas_yaml
+from faas_gitops.protocols.faas_template import FaaSTemplateProvider
+
+_INFO_FIELDS = {"displayName": "name", "description": "description", "icon": "icon", "tags": "tags"}
+_INFO_FIELDS_INV = {dst: src for src, dst in _INFO_FIELDS.items()}
+
+
+@dataclass
+class DriftResult:
+    """Container for drift detection results."""
+
+    drifted: list[str] = field(default_factory=list)
+    missing_in_git: list[str] = field(default_factory=list)
+    missing_in_faas: list[str] = field(default_factory=list)
+    diff_text: str = ""
+
+
+@dataclass(frozen=True, slots=True)
+class TemplateParts:
+    """Decomposed template: info dict + optional jinja/schema."""
+
+    info: dict
+    jinja: str | None = None
+    schema: dict | None = None
+
+    def to_faas_yaml(self) -> str:
+        """Reassemble into SiliconFunctionTemplate YAML for FaaS API."""
+        metadata: dict = {"name": f"{self.info['subject']}/{self.info['id']}"}
+        for dst, src in _INFO_FIELDS_INV.items():
+            if dst in self.info:
+                metadata[src] = self.info[dst]
+        if "parent" in self.info:
+            metadata["parentTemplateName"] = self.info["parent"]
+        spec: dict = {}
+        if self.jinja is not None:
+            spec["jinjaTemplate"] = self.jinja
+        if self.schema is not None:
+            spec["schema"] = self.schema
+        return dump_faas_yaml({
+            "apiVersion": "function-template.6scloud.com/v1alpha1",
+            "kind": "SiliconFunctionTemplate",
+            "metadata": metadata,
+            "spec": spec,
+        })
+
+
+@dataclass(frozen=True, slots=True)
+class FunctionParts:
+    """Decomposed function: meta + optional base/definition."""
+
+    meta: dict
+    base: dict | None = None
+    definition: dict | None = None
+
+
+    def to_faas_meta(self) -> dict:
+        return {"functionName": self.meta.get("functionName", ""), "tags": self.meta.get("tags", [])}
+
+    def to_faas_definition(self, comment: str = None) -> dict | None:
+        if self.definition is None:
+            return 
+        assert comment is not None 
+        return {"metadata": {"templateName": self.base["templateName"]}, "spec": {"data": self.definition, "comment": comment}, "kind": "SiliconFunctionDefinition", "apiVersion": "function-form-value.6scloud.com/v1alpha1"}
+
+    async def render_draft(self, provider: FaaSTemplateProvider, tpl_data: Dict) -> dict:
+        tpl_data.setdefault("spec", {})["examples"] = [self.definition]
+        with tempfile.NamedTemporaryFile(mode='w+', suffix='.yaml', delete=False) as tmp_file:
+            yaml.dump(tpl_data, tmp_file, default_flow_style=False, allow_unicode=True)
+            out = await provider.render_template_draft(file=tmp_file.name)
+            return out.to_dict()
+
+@dataclass
+class ApplyResult:
+    """Container for apply operation results."""
+
+    applied: list[str] = field(default_factory=list)
+    unchanged: list[str] = field(default_factory=list)
+    skipped: list[str] = field(default_factory=list)
+    failed: list[tuple[str, str]] = field(default_factory=list)

faas_gitops-0.2.1/src/faas_gitops/protocols/__init__.py

@@ -0,0 +1,9 @@
+from .faas_template import FaaSTemplateProvider
+from .faas_function import FaaSFunctionProvider
+from .git_gateway import GitWriter
+
+__all__ = [
+    "FaaSTemplateProvider",
+    "FaaSFunctionProvider",
+    "GitWriter",
+]

faas_gitops-0.2.1/src/faas_gitops/protocols/faas_function.py

@@ -0,0 +1,53 @@
+from __future__ import annotations
+
+from typing import Protocol, runtime_checkable
+
+
+@runtime_checkable
+class FaaSFunctionProvider(Protocol):
+    """Interface for FaaS function CRUD operations.
+
+    Implementations wrap the bizy-deploy SDK or any other
+    FaaS-compatible backend.  Used by sync (read) and apply
+    (read + write) use cases.
+    """
+
+    async def list_functions(self) -> list[dict]:
+        """List all accessible functions.
+
+        Returns:
+            List of function dicts with at least 'id', 'name', and 'tags' keys.
+        """
+        ...
+
+    async def get_latest_definition(self, func_id: str) -> dict | None:
+        """Get the latest function definition dict.
+
+        Args:
+            func_id: Function identifier.
+
+        Returns:
+            Definition dict, or None if no definitions exist.
+        """
+        ...
+
+    async def push_definition(self, func_id: str, data: dict, comment: str = "") -> str:
+        """Create a new function definition version.
+
+        Args:
+            func_id: Function identifier.
+            data: Definition payload dict.
+
+        Returns:
+            Version string of the newly created definition.
+        """
+        ...
+
+    async def update_function_meta(self, func_id: str, meta: dict) -> None:
+        """Update function metadata (name, tags).
+
+        Args:
+            func_id: Function identifier.
+            meta: Dict with 'functionName' and/or 'tags' keys.
+        """
+        ...