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

localstack_cli/cli/lpm.py

@@ -0,0 +1,138 @@
+import itertools
+import logging
+from multiprocessing.pool import ThreadPool
+
+import click
+from rich.console import Console
+
+from localstack_cli import config
+from localstack_cli.cli.exceptions import CLIError
+from localstack_cli.packages import InstallTarget, Package
+from localstack_cli.packages.api import NoSuchPackageException, PackagesPluginManager
+from localstack_cli.utils.bootstrap import setup_logging
+
+LOG = logging.getLogger(__name__)
+
+console = Console()
+
+
+@click.group()
+def cli():
+    """
+    The LocalStack Package Manager (lpm) CLI is a set of commands to install third-party packages used by localstack
+    service providers.
+
+    Here are some handy commands:
+
+    List all packages
+
+        python -m localstack.cli.lpm list
+
+    Install DynamoDB Local:
+
+        python -m localstack.cli.install dynamodb-local
+
+    Install all community packages, four in parallel:
+
+        python -m localstack.cli.lpm list | grep "/community" | cut -d'/' -f1 | xargs python -m localstack.cli.lpm install --parallel 4
+    """
+    setup_logging()
+
+
+def _do_install_package(package: Package, version: str = None, target: InstallTarget = None):
+    console.print(f"installing... [bold]{package}[/bold]")
+    try:
+        package.install(version=version, target=target)
+        console.print(f"[green]installed[/green] [bold]{package}[/bold]")
+    except Exception as e:
+        console.print(f"[red]error[/red] installing {package}: {e}")
+        raise e
+
+
+@cli.command()
+@click.argument("package", nargs=-1, required=True)
+@click.option(
+    "--parallel",
+    type=int,
+    default=1,
+    required=False,
+    help="how many installers to run in parallel processes",
+)
+@click.option(
+    "--version",
+    type=str,
+    default=None,
+    required=False,
+    help="version to install of a package",
+)
+@click.option(
+    "--target",
+    type=click.Choice([target.name.lower() for target in InstallTarget]),
+    default=None,
+    required=False,
+    help="target of the installation",
+)
+def install(
+    package: list[str],
+    parallel: int | None = 1,
+    version: str | None = None,
+    target: str | None = None,
+):
+    """Install one or more packages."""
+    try:
+        if target:
+            target = InstallTarget[str.upper(target)]
+        else:
+            # LPM is meant to be used at build-time, the default target is static_libs
+            target = InstallTarget.STATIC_LIBS
+
+        # collect installers and install in parallel:
+        console.print(f"resolving packages: {package}")
+        package_manager = PackagesPluginManager()
+        package_manager.load_all()
+        package_instances = package_manager.get_packages(package, version)
+
+        if parallel > 1:
+            console.print(f"install {parallel} packages in parallel:")
+
+        config.dirs.mkdirs()
+
+        with ThreadPool(processes=parallel) as pool:
+            pool.starmap(
+                _do_install_package,
+                zip(package_instances, itertools.repeat(version), itertools.repeat(target)),
+            )
+    except NoSuchPackageException as e:
+        LOG.debug(str(e), exc_info=e)
+        raise CLIError(str(e))
+    except Exception as e:
+        LOG.debug("one or more package installations failed.", exc_info=e)
+        raise CLIError("one or more package installations failed.")
+
+
+@cli.command(name="list")
+@click.option(
+    "-v",
+    "--verbose",
+    is_flag=True,
+    default=False,
+    required=False,
+    help="Verbose output (show additional info on packages)",
+)
+def list_packages(verbose: bool):
+    """List available packages of all repositories"""
+    package_manager = PackagesPluginManager()
+    package_manager.load_all()
+    packages = package_manager.get_all_packages()
+    for package_name, package_scope, package_instance in packages:
+        console.print(f"[green]{package_name}[/green]/{package_scope}")
+        if verbose:
+            for version in package_instance.get_versions():
+                if version == package_instance.default_version:
+                    console.print(f"  - [bold]{version} (default)[/bold]", highlight=False)
+                else:
+                    console.print(f"  - {version}", highlight=False)
+
+
+if __name__ == "__main__":
+    cli()

localstack_cli/cli/main.py

@@ -0,0 +1,22 @@
+import os
+
+
+def main():
+    # indicate to the environment we are starting from the CLI
+    os.environ["LOCALSTACK_CLI"] = "1"
+
+    # config profiles are the first thing that need to be loaded (especially before localstack.config!)
+    from .profiles import set_and_remove_profile_from_sys_argv
+
+    # WARNING: This function modifies sys.argv to remove the profile argument.
+    set_and_remove_profile_from_sys_argv()
+
+    # initialize CLI plugins
+    from .localstack import create_with_plugins
+
+    cli = create_with_plugins()
+    cli()
+
+
+if __name__ == "__main__":
+    main()

localstack_cli/cli/plugin.py

@@ -0,0 +1,39 @@
+import abc
+import logging
+import os
+
+import click
+from plux import Plugin, PluginManager
+
+LOG = logging.getLogger(__name__)
+
+
+class LocalstackCli:
+    group: click.Group
+
+    def __call__(self, *args, **kwargs):
+        self.group(*args, **kwargs)
+
+
+class LocalstackCliPlugin(Plugin):
+    namespace = "localstack_cli.plugins.cli"
+
+    def load(self, cli) -> None:
+        self.attach(cli)
+
+    @abc.abstractmethod
+    def attach(self, cli: LocalstackCli) -> None:
+        """
+        Attach commands to the `localstack` CLI.
+
+        :param cli: the cli object
+        """
+
+
+def load_cli_plugins(cli):
+    if os.environ.get("DEBUG_PLUGINS", "0").lower() in ("true", "1"):
+        # importing localstack.config is still quite expensive...
+        logging.basicConfig(level=logging.DEBUG)
+
+    loader = PluginManager("localstack_cli.plugins.cli", load_args=(cli,))
+    loader.load_all()

localstack_cli/cli/plugins.py

@@ -0,0 +1,134 @@
+import os
+import time
+
+import click
+from plux import PluginManager
+from plux.build.setuptools import find_plugins
+from plux.core.entrypoint import spec_to_entry_point
+from rich import print as rprint
+from rich.console import Console
+from rich.table import Table
+from rich.tree import Tree
+
+from localstack_cli.cli.exceptions import CLIError
+
+console = Console()
+
+
+@click.group()
+def cli():
+    """
+    The plugins CLI is a set of commands to help troubleshoot LocalStack's plugin mechanism.
+    """
+    pass
+
+
+@cli.command()
+@click.option("--where", type=str, default=os.path.abspath(os.curdir))
+@click.option("--exclude", multiple=True, default=())
+@click.option("--include", multiple=True, default=("*",))
+@click.option("--output", type=str, default="tree")
+def find(where, exclude, include, output):
+    """
+    Find plugins by scanning the given path for PluginSpecs.
+    It starts from the current directory if --where is not specified.
+    This is what a setup.py method would run as a build step, i.e., discovering entry points.
+    """
+    with console.status(f"Scanning path {where}"):
+        plugins = find_plugins(where, exclude, include)
+
+    if output == "tree":
+        tree = Tree("Entrypoints")
+        for namespace, entry_points in plugins.items():
+            node = tree.add(f"[bold]{namespace}")
+
+            t = Table()
+            t.add_column("Name")
+            t.add_column("Location")
+
+            for ep in entry_points:
+                key, value = ep.split("=")
+                t.add_row(key, value)
+
+            node.add(t)
+
+        rprint(tree)
+    elif output == "dict":
+        rprint(dict(plugins))
+    else:
+        raise CLIError(f"unknown output format {output}")
+
+
+@cli.command("list")
+@click.option("--namespace", type=str, required=True)
+def cmd_list(namespace):
+    """
+    List all available plugins using a PluginManager from available endpoints.
+    """
+    manager = PluginManager(namespace)
+
+    t = Table()
+    t.add_column("Name")
+    t.add_column("Factory")
+
+    for spec in manager.list_plugin_specs():
+        ep = spec_to_entry_point(spec)
+        t.add_row(spec.name, ep.value)
+
+    rprint(t)
+
+
+@cli.command()
+@click.option("--namespace", type=str, required=True)
+@click.option("--name", type=str, required=True)
+def load(namespace, name):
+    """
+    Attempts to load a plugin using a PluginManager.
+    """
+    manager = PluginManager(namespace)
+
+    with console.status(f"Loading {namespace}:{name}"):
+        then = time.time()
+        plugin = manager.load(name)
+        took = time.time() - then
+
+    rprint(
+        f":tada: successfully loaded [bold][green]{namespace}[/green][/bold]:[bold][cyan]{name}[/cyan][/bold] ({type(plugin)}"
+    )
+    rprint(f":stopwatch:  loading took {took:.4f} s")
+
+
+@cli.command()
+@click.option("--namespace", type=str)
+def cache(namespace):
+    """
+    Outputs the stevedore entrypoints cache from which plugins are loaded.
+    """
+    from stevedore._cache import _c
+
+    data = _c._get_data_for_path(None)
+
+    tree = Tree("Entrypoints")
+    for group, entry_points in data.get("groups").items():
+        if namespace and group != namespace:
+            continue
+        node = tree.add(f"[bold]{group}")
+
+        t = Table()
+        t.add_column("Name")
+        t.add_column("Value")
+
+        for key, value, _ in entry_points:
+            t.add_row(key, value)
+
+        node.add(t)
+
+        if namespace:
+            rprint(t)
+            return
+
+    rprint(tree)
+
+
+if __name__ == "__main__":
+    cli()

localstack_cli/cli/profiles.py

@@ -0,0 +1,65 @@
+import argparse
+import os
+import sys
+
+# important: this needs to be free of localstack imports
+
+
+def set_and_remove_profile_from_sys_argv():
+    """
+    Performs the following steps:
+
+    1. Use argparse to parse the command line arguments for the --profile flag.
+       All occurrences are removed from the sys.argv list, and the value from
+       the last occurrence is used.  This allows the user to specify a profile
+       at any point on the command line.
+
+    2. If a --profile flag is not found, check for the -p flag.  The first
+       occurrence of the -p flag is used and it is not removed from sys.argv.
+       The reasoning for this is that at least one of the CLI subcommands has
+       a -p flag, and we want to keep it in sys.argv for that command to
+       pick up.  An existing bug means that if a -p flag is used with a
+       subcommand, it could erroneously be used as the profile value as well.
+       This behaviour is undesired, but we must maintain back-compatibility of
+       allowing the profile to be specified using -p.
+
+    3. If a profile is found, the 'CONFIG_PROFILE' os variable is set
+       accordingly. This is later picked up by ``localstack.config``.
+
+    WARNING:  Any --profile options are REMOVED from sys.argv, so that they are
+              not passed to the localstack CLI. This allows the profile option
+              to be set at any point on the command line.
+    """
+    parser = argparse.ArgumentParser(add_help=False)
+    parser.add_argument("--profile")
+    namespace, sys.argv = parser.parse_known_args(sys.argv)
+    profile = namespace.profile
+
+    if not profile:
+        # if no profile is given, check for the -p argument
+        profile = parse_p_argument(sys.argv)
+
+    if profile:
+        os.environ["CONFIG_PROFILE"] = profile.strip()
+
+
+def parse_p_argument(args) -> str | None:
+    """
+    Lightweight arg parsing to find the first occurrence of ``-p <config>``, or ``-p=<config>`` and return the value of
+    ``<config>`` from the given arguments.
+
+    :param args: list of CLI arguments
+    :returns: the value of ``-p``.
+    """
+    for i, current_arg in enumerate(args):
+        if current_arg.startswith("-p="):
+            # if using the "<arg>=<value>" notation, we remove the "-p=" prefix to get the value
+            return current_arg[3:]
+        if current_arg == "-p":
+            # otherwise use the next arg in the args list as value
+            try:
+                return args[i + 1]
+            except IndexError:
+                return None
+
+    return None