localstack-extensions-utils 0.1.0__py3-none-any.whl

localstack_extensions/utils/__init__.py

@@ -0,0 +1,23 @@
+from localstack_extensions.utils.docker import (
+    ProxiedDockerContainerExtension,
+    ProxyResource,
+)
+from localstack_extensions.utils.h2_proxy import (
+    TcpForwarder,
+    apply_http2_patches_for_grpc_support,
+    get_headers_from_data_stream,
+    get_headers_from_frames,
+    get_frames_from_http2_stream,
+    ProxyRequestMatcher,
+)
+
+__all__ = [
+    "ProxiedDockerContainerExtension",
+    "ProxyResource",
+    "TcpForwarder",
+    "apply_http2_patches_for_grpc_support",
+    "get_headers_from_data_stream",
+    "get_headers_from_frames",
+    "get_frames_from_http2_stream",
+    "ProxyRequestMatcher",
+]

localstack_extensions/utils/docker.py

@@ -0,0 +1,290 @@
+import re
+import logging
+from functools import cache
+from typing import Callable
+import requests
+
+from localstack.config import is_env_true
+from localstack_extensions.utils.h2_proxy import (
+    apply_http2_patches_for_grpc_support,
+)
+from localstack.utils.docker_utils import DOCKER_CLIENT
+from localstack.extensions.api import Extension, http
+from localstack.http import Request
+from localstack.utils.container_utils.container_client import (
+    PortMappings,
+    SimpleVolumeBind,
+)
+from localstack.utils.net import get_addressable_container_host
+from localstack.utils.sync import retry
+from rolo import route
+from rolo.proxy import Proxy
+from rolo.routing import RuleAdapter, WithHost
+from werkzeug.datastructures import Headers
+
+LOG = logging.getLogger(__name__)
+
+
+class ProxiedDockerContainerExtension(Extension):
+    """
+    Utility class to create a LocalStack Extension which runs a Docker container that exposes a service
+    on one or more ports, with requests being proxied to that container through the LocalStack gateway.
+
+    Requests may potentially use HTTP2 with binary content as the protocol (e.g., gRPC over HTTP2).
+    To ensure proper routing of requests, subclasses can define the `http2_ports`.
+
+    For services requiring raw TCP proxying (e.g., native database protocols), use the `tcp_ports`
+    parameter to enable transparent TCP forwarding to the container.
+    """
+
+    name: str
+    """Name of this extension, which must be overridden in a subclass."""
+    image_name: str
+    """Docker image name"""
+    container_ports: list[int]
+    """List of network ports of the Docker container spun up by the extension"""
+    host: str | None
+    """
+    Optional host on which to expose the container endpoints.
+    Can be either a static hostname, or a pattern like `<regex("(.+\\.)?"):subdomain>myext.<domain>`
+    """
+    path: str | None
+    """Optional path on which to expose the container endpoints."""
+    command: list[str] | None
+    """Optional command (and flags) to execute in the container."""
+    env_vars: dict[str, str] | None
+    """Optional environment variables to pass to the container."""
+    volumes: list[SimpleVolumeBind] | None
+    """Optional volumes to mount into the container."""
+    health_check_fn: Callable[[], None] | None
+    """
+    Optional custom health check function. If not provided, defaults to HTTP GET on main_port.
+    The function should raise an exception if the health check fails.
+    """
+    health_check_retries: int
+    """Number of times to retry the health check before giving up."""
+    health_check_sleep: float
+    """Time in seconds to sleep between health check retries."""
+
+    request_to_port_router: Callable[[Request], int] | None
+    """Callable that returns the target port for a given request, for routing purposes"""
+    http2_ports: list[int] | None
+    """List of ports for which HTTP2 proxy forwarding into the container should be enabled."""
+    tcp_ports: list[int] | None
+    """
+    List of container ports for raw TCP proxying through the gateway.
+    Enables transparent TCP forwarding for protocols that don't use HTTP (e.g., native DB protocols).
+
+    When tcp_ports is set, the extension must implement tcp_connection_matcher() to identify
+    its traffic by inspecting initial connection bytes.
+    """
+
+    tcp_connection_matcher: Callable[[bytes], bool] | None
+    """
+    Optional function to identify TCP connections belonging to this extension.
+
+    Called with initial connection bytes (up to 512 bytes) to determine if this extension
+    should handle the connection. Return True to claim the connection, False otherwise.
+    """
+
+    def __init__(
+        self,
+        image_name: str,
+        container_ports: list[int],
+        host: str | None = None,
+        path: str | None = None,
+        command: list[str] | None = None,
+        env_vars: dict[str, str] | None = None,
+        volumes: list[SimpleVolumeBind] | None = None,
+        health_check_fn: Callable[[], None] | None = None,
+        health_check_retries: int = 60,
+        health_check_sleep: float = 1.0,
+        request_to_port_router: Callable[[Request], int] | None = None,
+        http2_ports: list[int] | None = None,
+        tcp_ports: list[int] | None = None,
+    ):
+        self.image_name = image_name
+        if not container_ports:
+            raise ValueError("container_ports is required")
+        self.container_ports = container_ports
+        self.host = host
+        self.path = path
+        self.container_name = re.sub(r"\W", "-", f"ls-ext-{self.name}")
+        self.command = command
+        self.env_vars = env_vars
+        self.volumes = volumes
+        self.health_check_fn = health_check_fn
+        self.health_check_retries = health_check_retries
+        self.health_check_sleep = health_check_sleep
+        self.request_to_port_router = request_to_port_router
+        self.http2_ports = http2_ports
+        self.tcp_ports = tcp_ports
+        self.main_port = self.container_ports[0]
+        self.container_host = get_addressable_container_host()
+
+    def update_gateway_routes(self, router: http.Router[http.RouteHandler]):
+        if self.path:
+            raise NotImplementedError(
+                "Path-based routing not yet implemented for this extension"
+            )
+        # note: for simplicity, starting the external container at startup - could be optimized over time ...
+        self.start_container()
+        # add resource for HTTP/1.1 requests
+        resource = RuleAdapter(ProxyResource(self.container_host, self.main_port))
+        if self.host:
+            resource = WithHost(self.host, [resource])
+        router.add(resource)
+
+        # apply patches to serve HTTP/2 requests
+        for port in self.http2_ports or []:
+            apply_http2_patches_for_grpc_support(
+                self.container_host, port, self.http2_request_matcher
+            )
+
+        # set up raw TCP proxies with protocol detection
+        if self.tcp_ports:
+            self._setup_tcp_protocol_routing()
+
+    def _setup_tcp_protocol_routing(self):
+        """
+        Set up TCP routing on the LocalStack gateway for this extension.
+
+        This method patches the gateway's HTTP protocol handler to intercept TCP
+        connections and allow this extension to claim them via tcp_connection_matcher().
+        This enables multiple TCP protocols to share the main gateway port (4566).
+
+        Uses monkeypatching to intercept dataReceived() before HTTP processing.
+        """
+        from localstack_extensions.utils.tcp_protocol_router import (
+            patch_gateway_for_tcp_routing,
+            register_tcp_extension,
+        )
+
+        # Get the connection matcher from the extension
+        matcher = getattr(self, "tcp_connection_matcher", None)
+        if not matcher:
+            LOG.warning(
+                f"Extension {self.name} has tcp_ports but no tcp_connection_matcher(). "
+                "TCP routing will not work without a matcher."
+            )
+            return
+
+        # Apply gateway patches (only happens once globally)
+        patch_gateway_for_tcp_routing()
+
+        # Register this extension for TCP routing
+        # Use first port as the default target port
+        target_port = self.tcp_ports[0] if self.tcp_ports else self.main_port
+
+        register_tcp_extension(
+            extension_name=self.name,
+            matcher=matcher,
+            backend_host=self.container_host,
+            backend_port=target_port,
+        )
+
+        LOG.info(
+            f"Registered TCP extension {self.name} -> {self.container_host}:{target_port} on gateway"
+        )
+
+    def http2_request_matcher(self, headers: Headers) -> bool:
+        """
+        Define whether an HTTP2 request should be proxied, based on request headers.
+
+        Default implementation returns False (no HTTP2 proxying).
+        Override this method in subclasses that need HTTP2 proxying.
+        """
+        return False
+
+    def on_platform_shutdown(self):
+        self._remove_container()
+
+    @cache
+    def start_container(self) -> None:
+        LOG.debug("Starting extension container %s", self.container_name)
+
+        port_mapping = PortMappings()
+        for port in self.container_ports:
+            port_mapping.add(port)
+
+        kwargs = {}
+        if self.command:
+            kwargs["command"] = self.command
+        if self.env_vars:
+            kwargs["env_vars"] = self.env_vars
+        if self.volumes:
+            kwargs["volumes"] = self.volumes
+
+        try:
+            DOCKER_CLIENT.run_container(
+                self.image_name,
+                detach=True,
+                remove=True,
+                name=self.container_name,
+                ports=port_mapping,
+                **kwargs,
+            )
+        except Exception as e:
+            LOG.debug("Failed to start container %s: %s", self.container_name, e)
+            # allow running the container in a local server in dev mode
+            if not is_env_true(f"{self.name.upper().replace('-', '_')}_DEV_MODE"):
+                raise
+
+        # Use custom health check if provided, otherwise default to HTTP GET
+        health_check = self.health_check_fn or self._default_health_check
+
+        try:
+            retry(
+                health_check,
+                retries=self.health_check_retries,
+                sleep=self.health_check_sleep,
+            )
+        except Exception as e:
+            LOG.info("Failed to connect to container %s: %s", self.container_name, e)
+            self._remove_container()
+            raise
+
+    def _default_health_check(self) -> None:
+        """Default health check: HTTP GET request to the main port."""
+        response = requests.get(f"http://{self.container_host}:{self.main_port}/")
+        assert response.ok
+
+    def _remove_container(self):
+        LOG.debug("Stopping extension container %s", self.container_name)
+        DOCKER_CLIENT.remove_container(
+            self.container_name, force=True, check_existence=False
+        )
+
+
+class ProxyResource:
+    """
+    Simple proxy resource that forwards incoming requests from the
+    LocalStack Gateway to the target Docker container.
+    """
+
+    host: str
+    port: int
+
+    def __init__(self, host: str, port: int):
+        self.host = host
+        self.port = port
+
+    @route("/<path:path>")
+    def index(self, request: Request, path: str, *args, **kwargs):
+        return self._proxy_request(request, forward_path=f"/{path}")
+
+    def _proxy_request(self, request: Request, forward_path: str, *args, **kwargs):
+        base_url = f"http://{self.host}:{self.port}"
+        proxy = Proxy(forward_base_url=base_url)
+
+        # update content length (may have changed due to content compression)
+        if request.method not in ("GET", "OPTIONS"):
+            request.headers["Content-Length"] = str(len(request.data))
+
+        # make sure we're forwarding the correct Host header
+        request.headers["Host"] = f"localhost:{self.port}"
+
+        # forward the request to the target
+        result = proxy.forward(request, forward_path=forward_path)
+
+        return result

localstack_extensions/utils/h2_proxy.py

@@ -0,0 +1,181 @@
+import logging
+import socket
+from enum import Enum
+from typing import Iterable, Callable
+
+from h2.frame_buffer import FrameBuffer
+from hpack import Decoder
+from hyperframe.frame import HeadersFrame, Frame
+from twisted.internet import reactor
+
+from localstack.utils.patch import patch
+from twisted.web._http2 import H2Connection
+from werkzeug.datastructures import Headers
+
+LOG = logging.getLogger(__name__)
+
+
+ProxyRequestMatcher = Callable[[Headers], bool]
+
+
+class TcpForwarder:
+    """Simple helper class for bidirectional forwarding of TCP traffic."""
+
+    buffer_size: int = 1024
+    """Data buffer size for receiving data from upstream socket."""
+
+    def __init__(self, port: int, host: str = "localhost"):
+        self.port = port
+        self.host = host
+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._socket.connect((self.host, self.port))
+        self._closed = False
+
+    def receive_loop(self, callback):
+        while data := self.recv(self.buffer_size):
+            callback(data)
+
+    def recv(self, length):
+        try:
+            return self._socket.recv(length)
+        except OSError as e:
+            if self._closed:
+                return None
+            else:
+                raise e
+
+    def send(self, data):
+        self._socket.sendall(data)
+
+    def close(self):
+        if self._closed:
+            return
+        LOG.debug(f"Closing connection to upstream HTTP2 server on port {self.port}")
+        self._closed = True
+        try:
+            self._socket.shutdown(socket.SHUT_RDWR)
+            self._socket.close()
+        except Exception:
+            # swallow exceptions here (e.g., "bad file descriptor")
+            pass
+
+
+patched_connection = False
+
+
+def apply_http2_patches_for_grpc_support(
+    target_host: str, target_port: int, http2_request_matcher: ProxyRequestMatcher
+):
+    """
+    Apply some patches to proxy incoming gRPC requests and forward them to a target port.
+    Note: this is a very brute-force approach and needs to be fixed/enhanced over time!
+    """
+    LOG.debug(f"Enabling proxying to backend {target_host}:{target_port}")
+    global patched_connection
+    assert not patched_connection, (
+        "It is not safe to patch H2Connection twice with this function"
+    )
+    patched_connection = True
+
+    class ForwardingState(Enum):
+        UNDECIDED = "undecided"
+        FORWARDING = "forwarding"
+        PASSTHROUGH = "passthrough"
+
+    class ForwardingBuffer:
+        """
+        A buffer atop the HTTP2 client connection, that will hold
+        data until the ProxyRequestMatcher tells us whether to send it
+        to the backend, or leave it to the default handler.
+        """
+
+        backend: TcpForwarder
+        buffer: list
+        state: ForwardingState
+
+        def __init__(self, http_response_stream):
+            self.http_response_stream = http_response_stream
+            LOG.debug(
+                f"Starting TCP forwarder to port {target_port} for new HTTP2 connection"
+            )
+            self.backend = TcpForwarder(target_port, host=target_host)
+            self.buffer = []
+            self.state = ForwardingState.UNDECIDED
+            reactor.getThreadPool().callInThread(
+                self.backend.receive_loop, self.received_from_backend
+            )
+
+        def received_from_backend(self, data):
+            self.http_response_stream.write(data)
+
+        def received_from_http2_client(self, data, default_handler: Callable):
+            match self.state:
+                case ForwardingState.PASSTHROUGH:
+                    default_handler(data)
+                case ForwardingState.FORWARDING:
+                    assert not self.buffer
+                    # Keep sending data to the backend for the lifetime of this connection
+                    self.backend.send(data)
+                case ForwardingState.UNDECIDED:
+                    self.buffer.append(data)
+
+                    if headers := get_headers_from_data_stream(self.buffer):
+                        buffered_data = b"".join(self.buffer)
+                        self.buffer = []
+
+                        if http2_request_matcher(headers):
+                            self.state = ForwardingState.FORWARDING
+                            self.backend.send(buffered_data)
+                        else:
+                            self.state = ForwardingState.PASSTHROUGH
+                            # if this is not a target request, then call the default handler
+                            default_handler(buffered_data)
+
+        def close(self):
+            self.backend.close()
+
+    @patch(H2Connection.connectionMade)
+    def _connectionMade(fn, self, *args, **kwargs):
+        self._ls_forwarding_buffer = ForwardingBuffer(self.transport)
+
+    @patch(H2Connection.dataReceived)
+    def _dataReceived(fn, self, data, *args, **kwargs):
+        self._ls_forwarding_buffer.received_from_http2_client(
+            data, lambda d: fn(self, d, *args, **kwargs)
+        )
+
+    @patch(H2Connection.connectionLost)
+    def connectionLost(fn, self, *args, **kwargs):
+        self._ls_forwarding_buffer.close()
+
+
+def get_headers_from_data_stream(data_list: Iterable[bytes]) -> Headers:
+    """Get headers from a data stream (list of bytes data), if any headers are contained."""
+    stream = b"".join(data_list)
+    return get_headers_from_frames(get_frames_from_http2_stream(stream))
+
+
+def get_headers_from_frames(frames: Iterable[Frame]) -> Headers:
+    """Parse the given list of HTTP2 frames and return a dict of headers, if any"""
+    result = {}
+    decoder = Decoder()
+    for frame in frames:
+        if isinstance(frame, HeadersFrame):
+            try:
+                headers = decoder.decode(frame.data)
+                result.update(dict(headers))
+            except Exception:
+                pass
+    return Headers(result)
+
+
+def get_frames_from_http2_stream(data: bytes) -> Iterable[Frame]:
+    """Parse the data from an HTTP2 stream into an iterable of frames"""
+    buffer = FrameBuffer(server=True)
+    buffer.max_frame_size = 16384
+    try:
+        buffer.add_data(data)
+        for frame in buffer:
+            yield frame
+    except Exception:
+        pass

localstack_extensions/utils/tcp_protocol_router.py

@@ -0,0 +1,179 @@
+"""
+Protocol-detecting TCP router for LocalStack Gateway.
+
+This module provides a Twisted protocol that detects the protocol from initial
+connection bytes and routes to the appropriate backend, enabling multiple TCP
+protocols to share a single gateway port.
+"""
+
+import logging
+from twisted.internet import reactor
+from twisted.protocols.portforward import ProxyClient, ProxyClientFactory
+from twisted.web.http import HTTPChannel
+
+from localstack.utils.patch import patch
+from localstack import config
+
+LOG = logging.getLogger(__name__)
+LOG.setLevel(logging.DEBUG if config.DEBUG else logging.INFO)
+
+# Global registry of extensions with TCP matchers
+# List of tuples: (extension_name, matcher_func, backend_host, backend_port)
+_tcp_extensions = []
+_gateway_patched = False
+
+
+class TcpProxyClient(ProxyClient):
+    """Backend TCP connection for protocol-detected connections."""
+
+    def connectionMade(self):
+        """Called when backend connection is established."""
+        server = self.factory.server
+
+        # Set up peer relationship
+        server.set_tcp_peer(self)
+
+        # Unregister any existing producer on server transport (HTTPChannel may have one)
+        try:
+            server.transport.unregisterProducer()
+        except Exception:
+            pass  # No producer was registered, which is fine
+
+        # Enable flow control
+        self.transport.registerProducer(server.transport, True)
+        server.transport.registerProducer(self.transport, True)
+
+        # Send buffered data from detection phase
+        if hasattr(self.factory, "initial_data"):
+            initial_data = self.factory.initial_data
+            self.transport.write(initial_data)
+            del self.factory.initial_data
+
+    def dataReceived(self, data):
+        """Forward data from backend to client."""
+        self.factory.server.transport.write(data)
+
+    def connectionLost(self, reason):
+        """Backend connection closed."""
+        self.factory.server.transport.loseConnection()
+
+
+def patch_gateway_for_tcp_routing():
+    """
+    Patch the LocalStack gateway to enable protocol detection and TCP routing.
+
+    This monkeypatches the HTTPChannel class used by the gateway to intercept
+    connections and detect TCP protocols before HTTP processing.
+    """
+    global _gateway_patched
+
+    if _gateway_patched:
+        return
+
+    # Patch HTTPChannel to use our protocol-detecting version
+    @patch(HTTPChannel.__init__)
+    def _patched_init(fn, self, *args, **kwargs):
+        # Call original init
+        fn(self, *args, **kwargs)
+        # Add our detection attributes
+        self._detection_buffer = []
+        self._detecting = True
+        self._tcp_peer = None
+
+    @patch(HTTPChannel.dataReceived)
+    def _patched_dataReceived(fn, self, data):
+        """Intercept data to allow extensions to claim TCP connections."""
+        if not getattr(self, "_detecting", False):
+            # Already decided - either proxying TCP or processing HTTP
+            if getattr(self, "_tcp_peer", None):
+                # TCP proxying mode
+                self._tcp_peer.transport.write(data)
+            else:
+                # HTTP mode - pass to original
+                fn(self, data)
+            return
+
+        # Still detecting - buffer data
+        if not hasattr(self, "_detection_buffer"):
+            self._detection_buffer = []
+        self._detection_buffer.append(data)
+        buffered_data = b"".join(self._detection_buffer)
+
+        # Try each registered extension's matcher
+        if len(buffered_data) >= 8:
+            for ext_name, matcher, backend_host, backend_port in _tcp_extensions:
+                try:
+                    if matcher(buffered_data):
+                        # Switch to TCP proxy mode
+                        self._detecting = False
+                        self.transport.pauseProducing()
+
+                        # Create backend connection
+                        client_factory = ProxyClientFactory()
+                        client_factory.protocol = TcpProxyClient
+                        client_factory.server = self
+                        client_factory.initial_data = buffered_data
+
+                        reactor.connectTCP(backend_host, backend_port, client_factory)
+                        return
+                except Exception as e:
+                    LOG.debug(f"Error in matcher for {ext_name}: {e}")
+                    continue
+
+            # No extension claimed the connection
+            self._detecting = False
+            # Feed buffered data to HTTP handler
+            for chunk in self._detection_buffer:
+                fn(self, chunk)
+            self._detection_buffer = []
+
+    @patch(HTTPChannel.connectionLost)
+    def _patched_connectionLost(fn, self, reason):
+        """Handle connection close."""
+        tcp_peer = getattr(self, "_tcp_peer", None)
+        if tcp_peer:
+            tcp_peer.transport.loseConnection()
+            self._tcp_peer = None
+        fn(self, reason)
+
+    # Monkey-patch the set_tcp_peer method onto HTTPChannel
+    def set_tcp_peer(self, peer):
+        """Called when backend TCP connection is established."""
+        self._tcp_peer = peer
+        self.transport.resumeProducing()
+
+    HTTPChannel.set_tcp_peer = set_tcp_peer
+
+    _gateway_patched = True
+
+
+def register_tcp_extension(
+    extension_name: str,
+    matcher: callable,
+    backend_host: str,
+    backend_port: int,
+):
+    """
+    Register an extension for TCP connection routing.
+
+    Args:
+        extension_name: Name of the extension
+        matcher: Function that takes bytes and returns bool to claim connection
+        backend_host: Backend host to route to
+        backend_port: Backend port to route to
+    """
+    _tcp_extensions.append((extension_name, matcher, backend_host, backend_port))
+    LOG.info(
+        f"Registered TCP extension {extension_name} -> {backend_host}:{backend_port}"
+    )
+
+
+def unregister_tcp_extension(extension_name: str):
+    """Unregister an extension from TCP routing."""
+    global _tcp_extensions
+    _tcp_extensions = [
+        (name, matcher, host, port)
+        for name, matcher, host, port in _tcp_extensions
+        if name != extension_name
+    ]
+    LOG.info(f"Unregistered TCP extension {extension_name}")

localstack_extensions_utils-0.1.0.dist-info/METADATA

@@ -0,0 +1,72 @@
+Metadata-Version: 2.4
+Name: localstack-extensions-utils
+Version: 0.1.0
+Summary: Utility library for LocalStack Extensions
+Author: LocalStack Team
+Project-URL: Homepage, https://github.com/localstack/localstack-extensions
+Keywords: LocalStack,Extensions,Utils
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown; charset=UTF-8
+Requires-Dist: h2
+Requires-Dist: hpack
+Requires-Dist: httpx
+Requires-Dist: hyperframe
+Requires-Dist: priority
+Requires-Dist: requests
+Requires-Dist: rolo
+Requires-Dist: twisted
+Provides-Extra: dev
+Requires-Dist: boto3; extra == "dev"
+Requires-Dist: build; extra == "dev"
+Requires-Dist: jsonpatch; extra == "dev"
+Requires-Dist: localstack; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Provides-Extra: test
+Requires-Dist: pytest>=7.0; extra == "test"
+Requires-Dist: pytest-timeout>=2.0; extra == "test"
+Requires-Dist: localstack; extra == "test"
+Requires-Dist: jsonpatch; extra == "test"
+Requires-Dist: grpcio>=1.60.0; extra == "test"
+Requires-Dist: grpcio-tools>=1.60.0; extra == "test"
+
+LocalStack Extensions Utils
+===========================
+
+A utility library providing common functionality for building [LocalStack Extensions](https://github.com/localstack/localstack-extensions).
+
+## Usage
+
+To use this library in your LocalStack extension, add it to the `dependencies` in your extension's `pyproject.toml`:
+
+```toml
+[project]
+dependencies = [
+    "localstack-extensions-utils",
+]
+```
+
+Or, to install directly from the GitHub repository:
+
+```toml
+[project]
+dependencies = [
+    "localstack-extensions-utils @ git+https://github.com/localstack/localstack-extensions.git#subdirectory=utils",
+]
+```
+
+Then import the utilities in your extension code, for example:
+
+```python
+from localstack_extensions.utils import ProxiedDockerContainerExtension
+
+...
+```
+
+## Dependencies
+
+This library requires LocalStack to be installed as it uses various LocalStack utilities for Docker management and networking.
+
+## License
+
+The code in this repo is available under the Apache 2.0 license.

localstack_extensions_utils-0.1.0.dist-info/RECORD

@@ -0,0 +1,9 @@
+localstack_extensions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+localstack_extensions/utils/__init__.py,sha256=YJUb7XLH4ClD2Axfjj3dbnEVjdrGSfj7Ju2Tp-6lf3o,611
+localstack_extensions/utils/docker.py,sha256=uLzxOg1aqcMlf27gokfeQcVc9mper_sfXDEmphWFnMg,11093
+localstack_extensions/utils/h2_proxy.py,sha256=CK6_GwyFcSqJ7If_gk-lrB-L6UkI8QmY9LgLL0IoN6s,6185
+localstack_extensions/utils/tcp_protocol_router.py,sha256=maWaM_3QfX4ESL1MZFPmBAeDw8cbiFLXqXN9eGnO6zs,6241
+localstack_extensions_utils-0.1.0.dist-info/METADATA,sha256=rgQDBwMOSr1D_OCLK_GnW5n_Bink7p2VU21mPN1pqQM,2061
+localstack_extensions_utils-0.1.0.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+localstack_extensions_utils-0.1.0.dist-info/top_level.txt,sha256=IJKbCHLaXVJ9YF0y8GtxlUc4fsJOW-H50t1-rSE1S6U,22
+localstack_extensions_utils-0.1.0.dist-info/RECORD,,

localstack_extensions_utils-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

localstack_extensions_utils-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+localstack_extensions