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

localstack_cli/pro/core/bootstrap/pods/api_types.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+
+class MergeStrategy(str, Enum):
+    """Enumerates the different strategies we can adopt when merging a state into LocalStack."""
+
+    OVERWRITE = "overwrite"
+    """The runtime state is wiped out and the incoming one is loaded."""
+    ACCOUNT_REGION_MERGE = "account-region-merge"
+    """Services sitting in different account-region pairs are merged. Technically, this level can also have conflicts
+    in the account/region-cross attributes."""
+    SERVICE_MERGE = "service-merge"
+    """Services are merged down to the account-region level if there is no resource overlap. Ideologically, a resource
+    is everything that have an ARN in AWS. In the internal implementation of LocalStack, a resource is a key in the
+    attribute dictionary of a store or moto backend."""
+    # RESOURCE_MERGE = "resource-merge"
+    """At this level, we merge everything down to the single AWS resource. This level is not yet implemented."""

localstack_cli/pro/core/bootstrap/pods/constants.py

@@ -0,0 +1,26 @@
+NIL_PTR = "NIL"
+
+# well-defined directory names
+ASSETS_ROOT_DIR = "assets"
+DEFAULT_POD_DIR = "cloudpods"
+OBJ_STORE_DIR = "objects"
+
+VERSION_FILE = "version.yaml"
+
+# regex pattern for cloud pod names
+POD_NAME_PATTERN = "^[a-zA-Z0-9_-]+$"
+# regex pattern for cloud pod versions - currently only numeric versions supported
+POD_VERSION_PATTERN = r"\d+"
+
+# The name of the zip file containing cloud pod state (i.e., pickled stores and assets)
+STATE_ZIP = "pod_state"
+# The name of the zip file containing the full version history
+VERSIONS_ARCHIVE = "version"
+# Compression format for the cloud pod
+COMPRESSION_FORMAT = "zip"
+
+# well-defined file names
+VERSION_SPACE_DIRS = [OBJ_STORE_DIR, VERSION_FILE]
+
+# header name that indicates internal requests made to LocalStack
+INTERNAL_REQUEST_PARAMS_HEADER = "x-localstack-data"

localstack_cli/pro/core/bootstrap/pods/remotes/api.py

@@ -0,0 +1,75 @@
+import json
+from abc import ABC, abstractmethod
+
+import requests
+from localstack_cli import config
+from localstack_cli.pro.core.bootstrap.pods.constants import INTERNAL_REQUEST_PARAMS_HEADER
+from localstack_cli.pro.core.constants import API_PATH_PODS
+
+
+class CloudPodsRemotesInterface(ABC):
+    """Service interface for the remote CRUD operations."""
+
+    @abstractmethod
+    def create_remote(self, name: str, protocols: list[str], remote_url: str | None = None) -> None:
+        """Creates a new remote with a given name.
+        :param name: The name of the remote.
+        :param protocols: The protocols supported by the remote.
+        :param remote_url: The URL of the remote.
+        TODO: think about security: we should check if the URL is either (1) localhost, or (2) using HTTPS.
+        """
+
+    @abstractmethod
+    def delete_remote(self, name: str) -> None:
+        """Deletes a named remote."""
+
+    @abstractmethod
+    def get_remote(self, name: str) -> dict[str, str]:
+        """Returns a named remote."""
+
+    @abstractmethod
+    def get_remotes(self) -> list[dict[str, str]]:
+        """Returns a list of all remotes."""
+
+
+class CloudPodsRemotesClient(CloudPodsRemotesInterface):
+    @property
+    def endpoint(self):
+        return f"{config.external_service_url()}{API_PATH_PODS}/remotes"
+
+    def create_remote(self, name: str, protocols: list[str], remote_url: str | None = None) -> None:
+        params = {"name": name, "protocols": protocols, "remote_url": remote_url}
+        response = self._client.post(
+            url=f"{self.endpoint}/{name}",
+            data=json.dumps(params),
+            headers={"Content-Type": "application/json"},
+        )
+        if not response.ok:
+            raise Exception(f"Failed to create remote: {response.content}")
+
+    def delete_remote(self, name: str) -> None:
+        response = self._client.delete(url=f"{self.endpoint}/{name}")
+        if not response.ok:
+            raise Exception(f"Failed to delete remote: {response.content}")
+
+    def get_remotes(self) -> list[dict[str, str]]:
+        response = self._client.get(url=self.endpoint)
+        if not response.ok:
+            raise Exception(f"Failed to get list of remotes: {response.content}")
+        remotes = json.loads(response.content)
+        return remotes.get("remotes", [])
+
+    def get_remote(self, name: str) -> dict[str, str]:
+        response = self._client.get(url=f"{self.endpoint}/{name}")
+        if not response.ok:
+            raise Exception(f"Failed to get remote: {response.content}")
+        remote = json.loads(response.content)
+        return remote
+
+    @property
+    def _client(self) -> requests.Session:
+        """Return an HTTP client session, adding default headers for all requests, as required"""
+        session = requests.Session()
+        # TODO: temporary fix to bypass Gateway 503 responses on LocalStack container shutdown
+        session.headers.update({INTERNAL_REQUEST_PARAMS_HEADER: "{}"})
+        return session

localstack_cli/pro/core/bootstrap/pods/remotes/configs.py

@@ -0,0 +1,69 @@
+from dataclasses import asdict, dataclass, field
+from urllib.parse import quote, urlparse
+
+DEFAULT_REMOTE_SCHEME = "platform"
+
+
+@dataclass
+class RemoteConfig:
+    """
+    Defines the configurations of a specific remote storage backend, used to perform cloud pods remote operations.
+
+    Note: For now, the remote config only consists of a URL, which would encapsulate all the details required to
+          interact with the remote (incl. auth tokens, etc). Over time, we may think of introducing a way to add
+          more fine-grained configurations for remotes.
+
+    Note: Remote URLs may contain `{..}` placeholders like `proto://{user}:{secret}@host', which will then
+          get replaced with concrete user parameters specified via `RemoteConfigParams` at runtime.
+
+    For the special case of our own remote platform (which is the default for remote operations), specifying the URL
+    is not required, and the access credentials are retrieved from the token cache populated on "localstack login".
+    """
+
+    remote_url: str
+    """The URL of the remote"""
+
+    @property
+    def scheme(self) -> str:
+        scheme = DEFAULT_REMOTE_SCHEME
+        if self.remote_url:
+            scheme = urlparse(self.remote_url).scheme
+        return scheme
+
+
+@dataclass
+class RemoteConfigParams:
+    """
+    Runtime parameters for cloud pod remotes, extracted from the user environment for remote operations.
+
+    The remote parameters typically contain credentials which are specified by the user and are then rendered
+    into the remote URL at runtime (to keep secret values ephemeral and avoid persisting them within URLs).
+    """
+
+    remote_name: str
+    """The name of the remote"""
+    remote_params: dict[str, str] = field(default_factory=dict)
+    """The runtime parameters of the remote"""
+
+    def render_url(self, remote_url: str) -> str:
+        """
+        Render the given remote URL template (e.g., 's3://{key}:{secret}@bucket') with the remote params.
+        """
+        if self.remote_params:
+            remote_params_escaped = {k: quote(v or "") for k, v in self.remote_params.items()}
+            remote_url = remote_url.format(**remote_params_escaped)
+        try:
+            # check if all placeholders have been replaced
+            remote_url.format()
+        except Exception as e:
+            raise Exception(
+                f"Missing parameters for cloud pod remote URL template: {remote_url}"
+            ) from e
+        return remote_url
+
+    def to_dict(self) -> dict:
+        return asdict(self)
+
+    @classmethod
+    def from_dict(cls, params: dict) -> "RemoteConfigParams":
+        return cls(**params)

localstack_cli/pro/core/bootstrap/pods/remotes/params.py

@@ -0,0 +1,86 @@
+import logging
+import os
+from collections.abc import Callable
+from urllib.parse import urlparse
+
+from localstack_cli.pro.core.bootstrap.pods.remotes.configs import DEFAULT_REMOTE_SCHEME
+
+LOG = logging.getLogger(__name__)
+
+PARAM_ACCESS_KEY_ID = "access_key_id"
+PARAM_SECRET_ACCESS_KEY = "secret_access_key"
+PARAM_SESSION_TOKEN = "session_token"
+
+
+def _get_aws_credentials_from_boto_session() -> dict[str, str] | None:
+    try:
+        import boto3
+
+        session = boto3.session.Session()
+        credentials = session.get_credentials()
+        return {
+            PARAM_ACCESS_KEY_ID: credentials.access_key,
+            PARAM_SECRET_ACCESS_KEY: credentials.secret_key,
+            PARAM_SESSION_TOKEN: credentials.token,
+        }
+    except Exception as e:
+        LOG.debug("Unable to extract remote parameters: %s", e)
+
+
+def get_s3_remote_params() -> dict[str, str]:
+    """
+    Returns the AWS credentials necessary to create the bucket storing the pods artifacts.
+    It first tries to fetch the credentials from a boto3 session. If this is not possible (e.g., boto3 not installed
+    on the host), it looks in the environment.
+    """
+    if params := _get_aws_credentials_from_boto_session():
+        return params
+
+    aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID")
+    aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+    aws_session_token = os.getenv("AWS_SESSION_TOKEN")
+
+    if not aws_access_key_id or not aws_secret_access_key:
+        raise Exception(
+            "Please export AWS_ACCESS_KEY_ID and AWS_SECRET_ACCESS_KEY in the environment"
+        )
+
+    params = {
+        PARAM_ACCESS_KEY_ID: aws_access_key_id,
+        PARAM_SECRET_ACCESS_KEY: aws_secret_access_key,
+    }
+    if aws_session_token:
+        params[PARAM_SESSION_TOKEN] = aws_session_token
+    return params
+
+
+def get_oras_remote_params() -> dict[str, str]:
+    # note: allow case-insensitive env. variables (all upper- or lower-case)
+    oras_username = os.getenv("ORAS_USERNAME") or os.getenv("oras_username")
+    oras_password = os.getenv("ORAS_PASSWORD") or os.getenv("oras_password")
+    if not oras_username or not oras_password:
+        raise Exception("Please specify ORAS_USERNAME and ORAS_PASSWORD in the environment")
+    return {"oras_username": oras_username, "oras_password": oras_password}
+
+
+def get_platform_remote_params() -> dict[str, str]:
+    # note: allow case-insensitive env. variables (all upper- or lower-case)
+    auth_token = os.getenv("LOCALSTACK_AUTH_TOKEN")
+    bearer_token = os.getenv("LOCALSTACK_BEARER_TOKEN")
+    api_key = os.getenv("LOCALSTACK_API_KEY")
+    if not auth_token and not api_key and not bearer_token:
+        raise Exception("Please specify LOCALSTACK_AUTH_TOKEN in the environment")
+    return {"api_key": api_key, "auth_token": auth_token, "bearer_token": bearer_token}
+
+
+remotes_protocols: dict[str, Callable[[], dict]] = {
+    "s3": get_s3_remote_params,
+    "oras": get_oras_remote_params,
+    "platform": get_platform_remote_params,
+}
+
+
+def get_remote_params_callable(url: str) -> Callable[[], dict] | None:
+    """Returns a Callable that retrieves the remote parameters for a given URL."""
+    protocol = urlparse(url).scheme or DEFAULT_REMOTE_SCHEME
+    return remotes_protocols.get(protocol, None)