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

localstack_cli/utils/serving.py

@@ -0,0 +1,187 @@
+import abc
+import logging
+import threading
+
+from localstack_cli.utils.net import is_port_open
+from localstack_cli.utils.sync import poll_condition
+from localstack_cli.utils.threads import FuncThread, start_thread
+
+LOG = logging.getLogger(__name__)
+
+
+class StopServer(Exception):
+    pass
+
+
+class Server(abc.ABC):
+    """
+    A Server implements the lifecycle of a server running in a thread.
+    """
+
+    def __init__(self, port: int, host: str = "localhost") -> None:
+        super().__init__()
+        self._thread: FuncThread | None = None
+
+        self._lifecycle_lock = threading.RLock()
+        self._stopped = threading.Event()
+        self._started = threading.Event()
+
+        self._host = host
+        self._port = port
+
+    @property
+    def host(self):
+        return self._host
+
+    @property
+    def port(self):
+        return self._port
+
+    @property
+    def protocol(self):
+        return "http"
+
+    @property
+    def url(self):
+        return f"{self.protocol}://{self.host}:{self.port}"
+
+    def get_error(self) -> Exception | None:
+        """
+        If the thread running the server returned with an Exception, then this function will return that exception.
+        """
+        if not self._started.is_set():
+            return None
+
+        future = self._thread.result_future
+        if future.done():
+            return future.exception()
+        return None
+
+    def wait_is_up(self, timeout: float = None) -> bool:
+        """
+        Waits until the server is started and is_up returns true.
+
+        :param timeout: the time in seconds to wait before returning false. If timeout is None, then wait indefinitely.
+        :returns: true if the server is up, false if not or the timeout was reached while waiting.
+        """
+        # first wait until the started event was called
+        self._started.wait(timeout=timeout)
+        # then poll the health check
+        return poll_condition(self.is_up, timeout=timeout)
+
+    def is_running(self) -> bool:
+        """
+        Checks whether the thread holding the server is running. The server may be running but not healthy (
+        is_running == True, is_up == False).
+
+        :returns: true if the server thread is running
+        """
+        if not self._started.is_set():
+            return False
+        if self._stopped.is_set():
+            return False
+        return self._thread.running
+
+    def is_up(self) -> bool:
+        """
+        Checks whether the server is up by executing the health check function.
+
+        :returns: false if the server has not been started or if the health check failed, true otherwise
+        """
+        if not self._started.is_set():
+            return False
+
+        try:
+            return True if self.health() else False
+        except Exception:
+            return False
+
+    def shutdown(self) -> None:
+        """
+        Attempts to shut down the server by calling the internal do_shutdown method. It only does this if the server
+        has been started. Repeated calls to this function have no effect.
+
+        :raises RuntimeError: shutdown was called before start
+        """
+        with self._lifecycle_lock:
+            if not self._started.is_set():
+                raise RuntimeError("cannot shutdown server before it is started")
+            if self._stopped.is_set():
+                return
+
+            self._thread.stop()
+            self._stopped.set()
+            self.do_shutdown()
+
+    def start(self) -> bool:
+        """
+        Starts the server by calling the internal do_run method in a new thread, and then returns True. Repeated
+        calls to this function have no effect but return False.
+
+        :return: True if the server was started in this call, False if the server was already started previously
+        """
+        with self._lifecycle_lock:
+            if self._started.is_set():
+                return False
+
+            self._thread = self.do_start_thread()
+            self._started.set()
+            return True
+
+    def join(self, timeout=None):
+        """
+        Waits for the given amount of time until the thread running the server returns. If the server hasn't started
+        yet, it first waits for the server to start.
+
+        :params: the time in seconds to wait. If None then wait indefinitely.
+        :raises TimeoutError: If the server didn't shut down before the given timeout.
+        """
+        if not self._started.is_set():
+            raise RuntimeError("cannot join server before it is started")
+
+        if not self._started.wait(timeout):
+            raise TimeoutError
+
+        try:
+            self._thread.result_future.result(timeout)
+        except TimeoutError:
+            raise
+        except Exception:
+            # Future.result() will re-raise the exception that was raised in the thread
+            return
+
+    def health(self):
+        """
+        Runs a health check on the server. The default implementation performs is_port_open on the server URL.
+        """
+        return is_port_open(self.url)
+
+    def do_start_thread(self) -> FuncThread:
+        """
+        Creates and starts the thread running the server. By default, it calls the do_run method in a FuncThread, but
+        can be overridden to if the subclass wants to return its own thread.
+        """
+
+        def _run(*_):
+            try:
+                return self.do_run()
+            except StopServer:
+                LOG.debug("stopping server %s", self.url)
+            finally:
+                self._stopped.set()
+
+        return start_thread(_run, name=f"server-{self.__class__.__name__}")
+
+    def do_run(self):
+        """
+        Runs the server (blocking method). (Needs to be overridden by subclasses of do_start_thread is not overridden).
+
+        :raises StopServer: can be raised by the subclass to indicate the server should be stopped.
+        """
+        pass
+
+    def do_shutdown(self):
+        """
+        Called when shutdown() is performed. (Should be overridden by subclasses).
+        """
+        pass

localstack_cli/utils/ssl.py

@@ -0,0 +1,71 @@
+import logging
+import os
+
+from localstack_cli import config
+from localstack_cli.constants import API_ENDPOINT, ASSETS_ENDPOINT
+from localstack_cli.utils.crypto import generate_ssl_cert
+from localstack_cli.utils.http import download
+from localstack_cli.utils.time import now
+from localstack_cli.version import __version__ as version
+
+LOG = logging.getLogger(__name__)
+
+# Download URLs
+SSL_CERT_URL = f"{ASSETS_ENDPOINT}/local-certs/localstack.cert.key?version={version}"
+SSL_CERT_URL_FALLBACK = f"{API_ENDPOINT}/proxy/localstack.cert.key?version={version}"
+
+# path for test certificate
+_SERVER_CERT_PEM_FILE = "server.test.pem"
+
+
+def install_predefined_cert_if_available():
+    try:
+        if config.SKIP_SSL_CERT_DOWNLOAD:
+            LOG.debug("Skipping download of local SSL cert, as SKIP_SSL_CERT_DOWNLOAD=1")
+            return
+        setup_ssl_cert()
+    except Exception:
+        pass
+
+
+def setup_ssl_cert() -> None:
+    target_file = get_cert_pem_file_path()
+
+    # cache file for 6 hours (non-enterprise) or forever (enterprise)
+    if os.path.exists(target_file):
+        cache_duration_secs = 24 * 60 * 60
+        mod_time = os.path.getmtime(target_file)
+        if mod_time > (now() - cache_duration_secs):
+            LOG.debug("Using cached SSL certificate (less than 6hrs since last update).")
+            return
+
+    # download certificate from GitHub artifacts
+    LOG.debug("Attempting to download local SSL certificate file")
+
+    # apply timeout (and fall back to using self-signed certs)
+    timeout = 5  # slightly higher timeout for our proxy
+    try:
+        download(SSL_CERT_URL, target_file, timeout=timeout, quiet=True)
+        LOG.debug("SSL certificate downloaded successfully")
+    except Exception:
+        # try fallback URL, directly from our API proxy
+        try:
+            download(SSL_CERT_URL_FALLBACK, target_file, timeout=timeout, quiet=True)
+            LOG.debug("SSL certificate downloaded successfully")
+        except Exception as e:
+            LOG.info(
+                "Unable to download local test SSL certificate from %s to %s (using self-signed cert as fallback): %s",
+                SSL_CERT_URL_FALLBACK,
+                target_file,
+                e,
+            )
+            raise
+
+
+def get_cert_pem_file_path():
+    return config.CUSTOM_SSL_CERT_PATH or os.path.join(config.dirs.cache, _SERVER_CERT_PEM_FILE)
+
+
+def create_ssl_cert(serial_number=None):
+    cert_pem_file = get_cert_pem_file_path()
+    return generate_ssl_cert(cert_pem_file, serial_number=serial_number)

localstack_cli/utils/strings.py

@@ -0,0 +1,245 @@
+import base64
+import binascii
+import hashlib
+import itertools
+import random
+import re
+import string
+import uuid
+import zlib
+
+from localstack_cli.config import DEFAULT_ENCODING
+
+_unprintables = (
+    range(0x00, 0x09),
+    range(0x0A, 0x0A),
+    range(0x0B, 0x0D),
+    range(0x0E, 0x20),
+    range(0xD800, 0xE000),
+    range(0xFFFE, 0x10000),
+)
+
+# regular expression for unprintable characters
+# Based on https://docs.aws.amazon.com/AWSSimpleQueueService/latest/APIReference/API_SendMessage.html
+#     #x9 | #xA | #xD | #x20 to #xD7FF | #xE000 to #xFFFD | #x10000 to #x10FFFF
+REGEX_UNPRINTABLE_CHARS = re.compile(
+    f"[{re.escape(''.join(map(chr, itertools.chain(*_unprintables))))}]"
+)
+
+
+def to_str(obj: str | bytes, encoding: str = DEFAULT_ENCODING, errors="strict") -> str:
+    """If ``obj`` is an instance of ``binary_type``, return
+    ``obj.decode(encoding, errors)``, otherwise return ``obj``"""
+    return obj.decode(encoding, errors) if isinstance(obj, bytes) else obj
+
+
+def to_bytes(obj: str | bytes, encoding: str = DEFAULT_ENCODING, errors="strict") -> bytes:
+    """If ``obj`` is an instance of ``text_type``, return
+    ``obj.encode(encoding, errors)``, otherwise return ``obj``"""
+    return obj.encode(encoding, errors) if isinstance(obj, str) else obj
+
+
+def truncate(data: str, max_length: int = 100) -> str:
+    data = str(data or "")
+    return (f"{data[:max_length]}...") if len(data) > max_length else data
+
+
+def is_string(s, include_unicode=True, exclude_binary=False):
+    if isinstance(s, bytes) and exclude_binary:
+        return False
+    if isinstance(s, str):
+        return True
+    if include_unicode and isinstance(s, str):
+        return True
+    return False
+
+
+def is_string_or_bytes(s):
+    return is_string(s) or isinstance(s, str) or isinstance(s, bytes)
+
+
+def is_base64(s):
+    regex = r"^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$"
+    return is_string(s) and re.match(regex, s)
+
+
+_re_camel_to_snake_case = re.compile("((?<=[a-z0-9])[A-Z]|(?!^)[A-Z](?=[a-z]))")
+
+
+def camel_to_snake_case(string: str) -> str:
+    return _re_camel_to_snake_case.sub(r"_\1", string).replace("__", "_").lower()
+
+
+def snake_to_camel_case(string: str, capitalize_first: bool = True) -> str:
+    components = string.split("_")
+    start_idx = 0 if capitalize_first else 1
+    components = [x.title() for x in components[start_idx:]]
+    return "".join(components)
+
+
+def hyphen_to_snake_case(string: str) -> str:
+    return string.replace("-", "_")
+
+
+def canonicalize_bool_to_str(val: bool) -> str:
+    return "true" if str(val).lower() == "true" else "false"
+
+
+def convert_to_printable_chars(value: list | dict | str) -> str:
+    """Removes all unprintable characters from the given string."""
+    from localstack_cli.utils.objects import recurse_object
+
+    if isinstance(value, (dict, list)):
+
+        def _convert(obj, **kwargs):
+            if isinstance(obj, str):
+                return convert_to_printable_chars(obj)
+            return obj
+
+        return recurse_object(value, _convert)
+
+    result = REGEX_UNPRINTABLE_CHARS.sub("", value)
+    return result
+
+
+def first_char_to_lower(s: str) -> str:
+    return s and f"{s[0].lower()}{s[1:]}"
+
+
+def first_char_to_upper(s: str) -> str:
+    return s and f"{s[0].upper()}{s[1:]}"
+
+
+def str_to_bool(value):
+    """Return the boolean value of the given string, or the verbatim value if it is not a string"""
+    if isinstance(value, str):
+        true_strings = ["true", "True"]
+        return value in true_strings
+    return value
+
+
+def str_insert(string, index, content):
+    """Insert a substring into an existing string at a certain index."""
+    return f"{string[:index]}{content}{string[index:]}"
+
+
+def str_remove(string, index, end_index=None):
+    """Remove a substring from an existing string at a certain from-to index range."""
+    end_index = end_index or (index + 1)
+    return f"{string[:index]}{string[end_index:]}"
+
+
+def str_startswith_ignore_case(value: str, prefix: str) -> bool:
+    return value[: len(prefix)].lower() == prefix.lower()
+
+
+def short_uid() -> str:
+    return str(uuid.uuid4())[0:8]
+
+
+def short_uid_from_seed(seed: str) -> str:
+    hash = hashlib.sha1(seed.encode("utf-8")).hexdigest()
+    truncated_hash = hash[:32]
+    return str(uuid.UUID(truncated_hash))[0:8]
+
+
+def long_uid() -> str:
+    return str(uuid.uuid4())
+
+
+def md5(string: str | bytes) -> str:
+    m = hashlib.md5()
+    m.update(to_bytes(string))
+    return m.hexdigest()
+
+
+def checksum_crc32(string: str | bytes) -> str:
+    bytes = to_bytes(string)
+    checksum = zlib.crc32(bytes)
+    return base64.b64encode(checksum.to_bytes(4, "big")).decode()
+
+
+def checksum_crc32c(string: str | bytes):
+    # import botocore locally here to avoid a dependency of the CLI to botocore
+    from botocore.httpchecksum import CrtCrc32cChecksum
+
+    checksum = CrtCrc32cChecksum()
+    checksum.update(to_bytes(string))
+    return base64.b64encode(checksum.digest()).decode()
+
+
+def checksum_crc64nvme(string: str | bytes):
+    # import botocore locally here to avoid a dependency of the CLI to botocore
+    from botocore.httpchecksum import CrtCrc64NvmeChecksum
+
+    checksum = CrtCrc64NvmeChecksum()
+    checksum.update(to_bytes(string))
+    return base64.b64encode(checksum.digest()).decode()
+
+
+def hash_sha1(string: str | bytes) -> str:
+    digest = hashlib.sha1(to_bytes(string)).digest()
+    return base64.b64encode(digest).decode()
+
+
+def hash_sha256(string: str | bytes) -> str:
+    digest = hashlib.sha256(to_bytes(string)).digest()
+    return base64.b64encode(digest).decode()
+
+
+def base64_to_hex(b64_string: str) -> bytes:
+    return binascii.hexlify(base64.b64decode(b64_string))
+
+
+def base64_decode(data: str | bytes) -> bytes:
+    """Decode base64 data - with optional padding, and able to handle urlsafe encoding (containing -/_)."""
+    data = to_str(data)
+    missing_padding = len(data) % 4
+    if missing_padding != 0:
+        data = to_str(data) + "=" * (4 - missing_padding)
+    if "-" in data or "_" in data:
+        return base64.urlsafe_b64decode(data)
+    return base64.b64decode(data)
+
+
+def get_random_hex(length: int) -> str:
+    return "".join(random.choices(string.hexdigits[:16], k=length)).lower()
+
+
+def remove_leading_extra_slashes(input: str) -> str:
+    """
+    Remove leading extra slashes from the given input string.
+    Example: '///foo/bar' -> '/foo/bar'
+    """
+    return re.sub(r"^/+", "/", input)
+
+
+def prepend_with_slash(input: str) -> str:
+    """
+    Prepend a slash `/` to a given string if it does not have one already.
+    """
+    if not input.startswith("/"):
+        return f"/{input}"
+    return input
+
+
+def key_value_pairs_to_dict(pairs: str, delimiter: str = ",", separator: str = "=") -> dict:
+    """
+    Converts a string of key-value pairs to a dictionary.
+
+    Args:
+        pairs (str): A string containing key-value pairs separated by a delimiter.
+        delimiter (str): The delimiter used to separate key-value pairs (default is comma ',').
+        separator (str): The separator between keys and values (default is '=').
+
+    Returns:
+        dict: A dictionary containing the parsed key-value pairs.
+    """
+    splits = [split_pair.partition(separator) for split_pair in pairs.split(delimiter)]
+    return {key.strip(): value.strip() for key, _, value in splits}
+
+
+def token_generator(item: str) -> str:
+    base64_bytes = base64.b64encode(item.encode("utf-8"))
+    token = base64_bytes.decode("utf-8")
+    return token