playground-ls-cli 4.14.1.dev8__py3-none-any.whl

localstack_cli/pro/core/bootstrap/entitlements.py

@@ -0,0 +1,117 @@
+import fnmatch
+from collections.abc import Iterable, Iterator
+from typing import Any, TypedDict
+
+from localstack_cli.utils.numbers import to_number
+
+
+class ProductInfo(TypedDict):
+    """
+    A description of the product being licensed. Does not necessarily map to the stripe products.
+    """
+
+    name: str
+    version: str
+    metadata: dict[str, Any] | None
+
+
+class ProductEntitlements:
+    """
+    Helper for feature gating with the product entitlement information embedded in a license document.
+
+    Currently, two types of features/entitlements are supported:
+    * Boolean features (`has_entitlement`)
+    * Numerical limits (`get_entitlement_limit`)
+
+    To be extended in the future to support other types of features/entitlements.
+    """
+
+    def __init__(
+        self,
+        products: Iterable[ProductInfo],
+        allow_all: bool = False,
+    ):
+        self._products = list(products)
+        self._allow_all = allow_all
+
+    def __contains__(self, entitlement: str) -> bool:
+        return self.has_entitlement(entitlement)
+
+    def __iter__(self) -> Iterator[ProductInfo]:
+        return iter(self._products)
+
+    def has_entitlement(self, entitlement: str) -> bool:
+        """
+        Check if an entitlement is part of the currently active license.
+
+        The comparison uses fnmatch to compare, so the license could contain a ProductInfo record
+        ``localstack.extensions/*`` which would give access to all restricted extensions.
+
+        :param entitlement: The entitlement to check, for example ``localstack.extensions/foo``.
+        :return: True if the entitlement is part of the active license.
+        """
+        if self._allow_all:
+            return True
+
+        return self._get_product_info(entitlement, pattern_matching=True) is not None
+
+    def get_entitlement_limit(
+        self,
+        entitlement: str,
+        default: int | float | None = None,
+    ) -> int | float | None:
+        """
+        Returns the numerical limit configured for the given feature.
+
+        :param entitlement: The entitlement to check, for example ``localstack.extensions/foo``.
+        :param default: The default value to return if the entitlement is not part of the active license or the limit
+                        cannot be determined.
+        :return: The limit configured for the given entitlement, or the default value if the entitlement is not part of
+                 the active license or the limit cannot be determined.
+        """
+        product = self._get_product_info(entitlement)
+        if not product:
+            return default
+
+        metadata = self._get_metadata(product)
+        if metadata is None:
+            return default
+
+        raw_limit = metadata.get("limit")
+        if raw_limit is None:
+            return default
+
+        try:
+            limit = to_number(raw_limit)
+        except Exception:
+            return default
+
+        if limit is None or isinstance(limit, bool):
+            return default
+
+        return limit
+
+    def _get_product_info(
+        self, entitlement: str, pattern_matching: bool = False
+    ) -> ProductInfo | None:
+        for product in self._products:
+            pattern = product.get("name")
+            if not pattern:
+                continue
+
+            pattern = str(pattern)
+
+            if "*" in pattern and pattern_matching:
+                if fnmatch.fnmatch(entitlement, pattern):
+                    return product
+            elif pattern == entitlement:
+                return product
+
+        return None
+
+    def _get_metadata(self, product: ProductInfo) -> dict[str, Any] | None:
+        metadata = product.get("metadata")
+        if metadata is None or not isinstance(metadata, dict):
+            return None
+
+        return metadata

localstack_cli/pro/core/bootstrap/extensions/__init__.py

@@ -0,0 +1,3 @@
+"""Internal tools to operate extensions."""
+
+name = "extensions"

localstack_cli/pro/core/bootstrap/extensions/__main__.py

@@ -0,0 +1,106 @@
+"""Simple internal CLI script used to communicate between the container and the host CLI in
+``localstack.pro.core.cli.extensions."""
+
+import json
+import os
+import traceback
+
+import click
+from localstack_cli import config
+
+from . import repository
+
+
+@click.group("extensions")
+def cli():
+    from localstack_cli.pro.core.bootstrap import licensingv2
+    from localstack_cli.utils.bootstrap import setup_logging
+
+    setup_logging()
+
+    # we activate the license here to make sure that extensions that import encrypted code on
+    # module level can be resolved and don't lead to errors
+    licensingv2.get_licensed_environment().activate()
+
+
+@cli.command("debug")
+def debug():
+    """
+    Print debug information about localstack directories and run ``pip list`` in the extensions venv.
+    """
+    click.echo("Directories")
+    click.echo("===========")
+    for k, v in config.dirs.__dict__.items():
+        click.echo(f"{k:13} {v}")
+
+    click.echo()
+    click.echo("Extensions venv")
+    click.echo("===============")
+    venv = repository.LOCALSTACK_VENV
+    click.echo(f"localstack venv: {venv.venv_dir}")
+    click.echo(f"  site-packages: {venv.site_dir if venv.exists else 'not initialized'}")
+    venv = repository.get_extensions_venv()
+    click.echo(f"extensions venv: {venv.venv_dir}")
+    click.echo(f"  site-packages: {venv.site_dir if venv.exists else 'not initialized'}")
+
+    click.echo()
+    click.echo("pip list")
+    click.echo("========")
+    os.system(f"bash -c '. {venv.venv_dir}/bin/activate && pip list'")
+
+
+@cli.command("init")
+def init():
+    """
+    Initialize the extensions repository.
+    """
+    repository.init_extension_venv()
+
+
+@cli.command("list")
+def list_():
+    """Print the extension metadata as NDJSON to stdout."""
+    for extension in repository.list_extension_metadata():
+        click.echo(json.dumps(extension))
+
+
+@cli.command("install")
+@click.argument("name", required=True)
+def install(name: str):
+    try:
+        repo = repository.ExtensionsRepository()
+        for event in repo.run_install(name):
+            click.echo(json.dumps(event))
+    except Exception as e:
+        click.echo(
+            json.dumps(
+                {
+                    "event": "exception",
+                    "message": f"Error while installing extension: {e}",
+                    "extra": {"traceback": traceback.format_exc()},
+                }
+            )
+        )
+
+
+@cli.command("uninstall")
+@click.argument("name", required=True)
+def uninstall(name: str):
+    try:
+        repo = repository.ExtensionsRepository()
+        for event in repo.run_uninstall(name):
+            click.echo(json.dumps(event))
+    except Exception as e:
+        click.echo(
+            json.dumps(
+                {
+                    "event": "exception",
+                    "message": f"Error while uninstalling extension: {e}",
+                    "extra": {"traceback": traceback.format_exc()},
+                }
+            )
+        )
+
+
+if __name__ == "__main__":
+    cli()

localstack_cli/pro/core/bootstrap/extensions/autoinstall.py

@@ -0,0 +1,63 @@
+"""
+Used from the docker-entrypoint.sh to auto-install extensions configured in ``EXTENSION_AUTO_INSTALL`` or
+located in ``/etc/localstack/conf.d/extensions.txt``.
+"""
+
+import os.path
+import traceback
+
+from localstack_cli import config
+from localstack_cli.pro.core import config as pro_config
+
+from .repository import SubprocessLineStream, get_extension_repository
+
+
+def log(msg: str):
+    print(f"Localstack extensions installer: {msg}")
+
+
+def main():
+    if not pro_config.ACTIVATE_PRO:
+        return
+
+    extensions_txt = os.path.join(config.dirs.config, "extensions.txt")
+    auto_installable = pro_config.EXTENSION_AUTO_INSTALL
+
+    if not os.path.exists(extensions_txt) and not auto_installable:
+        # no extensions to install
+        return
+
+    # this will create an extensions venv directory if it doesn't exist
+    repo = get_extension_repository()
+
+    # install extensions.txt first
+    if os.path.exists(extensions_txt):
+        log(f"installing extensions defined in {extensions_txt}")
+        cmd = [
+            repo.pip,
+            "install",
+            "--no-input",
+            "--no-color",
+            "--disable-pip-version-check",
+            "-r",
+            extensions_txt,
+        ]
+        with SubprocessLineStream.open(cmd) as stream:
+            for line in stream:
+                log(line)
+
+    # install from variable next
+    log("installing extensions defined EXTENSIONS_AUTO_INSTALL")
+    for name_or_url in auto_installable:
+        log(f"auto installing extension {name_or_url}")
+        # TODO: proper output formatting
+        try:
+            for event in repo.run_install(name_or_url=name_or_url):
+                log(event.get("message"))
+        except Exception as e:
+            log(f"{e}")
+            log(traceback.format_exc())
+
+
+if __name__ == "__main__":
+    main()

localstack_cli/pro/core/bootstrap/extensions/bootstrap.py

@@ -0,0 +1,97 @@
+"""Hooks for extension developer mode on the host CLI."""
+
+from __future__ import annotations
+
+import logging
+import os
+from pathlib import Path
+from tempfile import gettempdir
+
+from localstack_cli import config
+from localstack_cli.utils.bootstrap import Container
+from localstack_cli.utils.container_utils.container_client import BindMount
+from localstack_cli.utils.json import FileMappedDocument
+from localstack_cli.utils.strings import md5
+
+LOG = logging.getLogger(__name__)
+
+_ENTRYPOINT_SCRIPT = """#!/bin/bash
+echo "=================================================="
+echo "LocalStack extension developer mode enabled"
+shopt -s nullglob
+
+pkgs=$(echo /opt/code/localstack/.venv/lib/python3*/site-packages)
+
+echo "import localstack_extensions_resolve;localstack_extensions_resolve.resolve()" > ${pkgs}/localstack-extensions-resolve.pth
+
+cat << EOF >> ${pkgs}/localstack_extensions_resolve.py
+import os
+import sys
+import glob
+
+base_dirs_visited = set()
+
+def append_pth_recursively(base_dir):
+    if base_dir in base_dirs_visited:
+        return
+    base_dirs_visited.add(base_dir)
+
+    for f in glob.glob(f"{base_dir}/*.pth", recursive=True):
+        with open(f, "r") as fd:
+            abs_path = os.path.abspath(os.path.dirname(f))
+            lines = fd.readlines()
+            for line in lines:
+                if line := line.strip():
+                    if "import" in line:
+                        continue
+                    module_dir = os.path.abspath(os.path.join(abs_path, line)) if not os.path.isabs(line) else line
+                    if os.path.exists(module_dir) and os.path.isdir(module_dir):
+                        if module_dir not in sys.path:
+                            sys.path.append(module_dir)
+                        append_pth_recursively(module_dir)
+
+
+def resolve():
+    append_pth_recursively(os.path.dirname(__file__))
+EOF
+
+for d in /opt/code/extensions/* ;
+do
+    echo "- mounting extension ${d}"
+    find ${d} -type d -name "site-packages" >> ${pkgs}/localstack-extensions-venv.pth
+    echo ${d} >> ${pkgs}/localstack-extensions-venv.pth
+done
+echo "Resuming normal execution, ..."
+echo "=================================================="
+exec /usr/local/bin/docker-entrypoint.sh
+"""
+
+_host_extension_dirs: list[str] = []
+
+
+def run_on_configure_host_hook():
+    """Load extension directories from ~/.localstack/extensions-dev.json."""
+    doc = FileMappedDocument(os.path.join(config.CONFIG_DIR, "extensions-dev.json"))
+
+    for extensions_spec in doc.get("extensions", []):
+        path = extensions_spec.get("host_path")
+        if path and os.path.exists(path):
+            _host_extension_dirs.append(path)
+
+
+def run_on_configure_localstack_container_hook(container: Container):
+    """Configure container for extension dev mode."""
+    # Create and mount custom entrypoint script
+    h = md5(_ENTRYPOINT_SCRIPT)
+    file = Path(gettempdir(), f"docker-entrypoint-{h}.sh")
+    if not file.exists():
+        file.write_text(_ENTRYPOINT_SCRIPT, newline="\n", encoding="utf-8")
+        file.chmod(0o777)
+
+    container.config.volumes.add(BindMount(str(file), f"/tmp/{file.name}"))
+    container.config.entrypoint = f"/tmp/{file.name}"
+
+    # Mount extension directories
+    for ext_dir in _host_extension_dirs:
+        target = os.path.join("/opt/code/extensions", os.path.basename(ext_dir))
+        container.config.volumes.add(BindMount(ext_dir, target, read_only=True))