plain.tunnel 0.1.0__tar.gz

plain_tunnel-0.1.0/LICENSE

@@ -0,0 +1,30 @@
+## Plain is released under the BSD 3-Clause License
+
+BSD 3-Clause License
+
+Copyright (c) 2023, Dropseed, LLC
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

plain_tunnel-0.1.0/PKG-INFO

@@ -0,0 +1,34 @@
+Metadata-Version: 2.1
+Name: plain.tunnel
+Version: 0.1.0
+Summary: 
+Home-page: https://plainframework.com
+License: BSD-3-Clause
+Author: Dave Gaeddert
+Author-email: dave.gaeddert@dropseed.dev
+Requires-Python: >=3.11,<4.0
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Requires-Dist: click (>=8.0.0)
+Requires-Dist: plain (<1.0.0)
+Requires-Dist: websockets
+Project-URL: Documentation, https://plainframework.com/docs/
+Project-URL: Repository, https://github.com/dropseed/plain
+Description-Content-Type: text/markdown
+
+<!-- This file is compiled from plain-pytest/plain/pytest/README.md. Do not edit this file directly. -->
+
+## Testing - pytest
+
+Write and run tests with pytest.
+
+Django includes its own test runner and [unittest](https://docs.python.org/3/library/unittest.html#module-unittest) classes.
+But a lot of people (myself included) prefer [pytest](https://docs.pytest.org/en/latest/contents.html).
+
+In Plain I've removed the Django test runner and a lot of the implications that come with it.
+There are a few utilities that remain to make testing easier,
+and `plain-test` is a wrapper around `pytest`.
+

plain_tunnel-0.1.0/README.md

@@ -0,0 +1,12 @@
+<!-- This file is compiled from plain-pytest/plain/pytest/README.md. Do not edit this file directly. -->
+
+## Testing - pytest
+
+Write and run tests with pytest.
+
+Django includes its own test runner and [unittest](https://docs.python.org/3/library/unittest.html#module-unittest) classes.
+But a lot of people (myself included) prefer [pytest](https://docs.pytest.org/en/latest/contents.html).
+
+In Plain I've removed the Django test runner and a lot of the implications that come with it.
+There are a few utilities that remain to make testing easier,
+and `plain-test` is a wrapper around `pytest`.

plain_tunnel-0.1.0/plain/tunnel/README.md

@@ -0,0 +1 @@
+## plain.tunnel

plain_tunnel-0.1.0/plain/tunnel/__init__.py

@@ -0,0 +1,3 @@
+from .cli import cli
+
+__all__ = ["cli"]

plain_tunnel-0.1.0/plain/tunnel/cli.py

@@ -0,0 +1,43 @@
+import getpass
+import random
+import string
+
+import click
+
+from .client import TunnelClient
+
+
+@click.command()
+@click.argument("destination")
+@click.option(
+    "--subdomain",
+    help="The subdomain to use for the tunnel.",
+    envvar="PLAIN_TUNNEL_SUBDOMAIN",
+)
+@click.option(
+    "--tunnel-host", envvar="PLAIN_TUNNEL_HOST", hidden=True, default="plaintunnel.com"
+)
+@click.option("--debug", "log_level", flag_value="DEBUG", help="Enable debug logging.")
+@click.option(
+    "--quiet", "log_level", flag_value="WARNING", help="Only log warnings and errors."
+)
+def cli(destination, subdomain, tunnel_host, log_level):
+    if not destination.startswith("http://") and not destination.startswith("https://"):
+        destination = f"https://{destination}"
+
+    if not log_level:
+        log_level = "INFO"
+
+    if not subdomain:
+        # Generate a subdomain using the system username + 7 random characters
+        random_chars = "".join(random.choices(string.ascii_lowercase, k=7))
+        subdomain = f"{getpass.getuser()}-{random_chars}"
+
+    tunnel = TunnelClient(
+        destination_url=destination,
+        subdomain=subdomain,
+        tunnel_host=tunnel_host,
+        log_level=log_level,
+    )
+    click.secho(f"Tunneling {tunnel.tunnel_http_url} -> {destination}", bold=True)
+    tunnel.run()

plain_tunnel-0.1.0/plain/tunnel/client.py

@@ -0,0 +1,316 @@
+import asyncio
+import json
+import logging
+import ssl
+import urllib.error
+import urllib.request
+from urllib.parse import urlparse
+
+import click
+import websockets
+
+
+class TunnelClient:
+    def __init__(self, *, destination_url, subdomain, tunnel_host, log_level):
+        self.destination_url = destination_url
+        self.subdomain = subdomain
+        self.tunnel_host = tunnel_host
+
+        self.tunnel_http_url = f"https://{subdomain}.{tunnel_host}"
+        self.tunnel_websocket_url = f"wss://{subdomain}.{tunnel_host}"
+
+        # Set up logging
+        self.logger = logging.getLogger(__name__)
+        self.logger.setLevel(getattr(logging, log_level.upper()))
+        ch = logging.StreamHandler()
+        ch.setLevel(getattr(logging, log_level.upper()))
+        formatter = logging.Formatter("%(message)s")
+        ch.setFormatter(formatter)
+        self.logger.addHandler(ch)
+
+        # Store incoming requests
+        self.pending_requests = {}
+
+        # Create the event loop
+        self.loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self.loop)
+        self.stop_event = asyncio.Event()
+
+    async def connect(self):
+        retry_count = 0
+        max_retries = 5
+        while not self.stop_event.is_set():
+            if retry_count >= max_retries:
+                self.logger.error(
+                    f"Failed to connect after {max_retries} retries. Exiting."
+                )
+                break
+            try:
+                self.logger.debug(
+                    f"Connecting to WebSocket URL: {self.tunnel_websocket_url}"
+                )
+                async with websockets.connect(
+                    self.tunnel_websocket_url, max_size=None
+                ) as websocket:
+                    self.logger.debug("WebSocket connection established")
+                    click.secho(
+                        f"Connected to tunnel {self.tunnel_http_url}", fg="green"
+                    )
+                    retry_count = 0  # Reset retry count on successful connection
+                    await self.forward_request(websocket)
+            except (websockets.ConnectionClosed, ConnectionError) as e:
+                if self.stop_event.is_set():
+                    self.logger.debug("Stopping reconnect attempts due to shutdown")
+                    break
+                retry_count += 1
+                self.logger.warning(
+                    f"Connection lost: {e}. Retrying in 2 seconds... ({retry_count}/{max_retries})"
+                )
+                await asyncio.sleep(2)
+            except asyncio.CancelledError:
+                self.logger.debug("Connection cancelled")
+                break
+            except Exception as e:
+                if self.stop_event.is_set():
+                    self.logger.debug("Stopping reconnect attempts due to shutdown")
+                    break
+                retry_count += 1
+                self.logger.error(
+                    f"Unexpected error: {e}. Retrying in 2 seconds... ({retry_count}/{max_retries})"
+                )
+                await asyncio.sleep(2)
+
+    async def forward_request(self, websocket):
+        try:
+            async for message in websocket:
+                if isinstance(message, str):
+                    # Received text message (metadata)
+                    self.logger.debug("Received metadata from worker")
+                    data = json.loads(message)
+                    await self.handle_request_metadata(websocket, data)
+                elif isinstance(message, bytes):
+                    # Received binary message (body chunk)
+                    self.logger.debug("Received binary data from worker")
+                    await self.handle_request_body_chunk(websocket, message)
+                else:
+                    self.logger.warning("Received unknown message type")
+        except asyncio.CancelledError:
+            self.logger.debug("Forward request cancelled")
+        except Exception as e:
+            self.logger.error(f"Error in forward_request: {e}")
+            raise
+
+    async def handle_request_metadata(self, websocket, data):
+        request_id = data["id"]
+        has_body = data.get("has_body", False)
+        total_body_chunks = data.get("totalBodyChunks", 0)
+        self.pending_requests[request_id] = {
+            "metadata": data,
+            "body_chunks": {},
+            "has_body": has_body,
+            "total_body_chunks": total_body_chunks,
+        }
+        self.logger.debug(
+            f"Stored metadata for request ID: {request_id}, has_body: {has_body}"
+        )
+        await self.check_and_process_request(websocket, request_id)
+
+    async def handle_request_body_chunk(self, websocket, chunk_data):
+        offset = 0
+
+        # Extract id_length
+        id_length = int.from_bytes(chunk_data[offset : offset + 4], byteorder="little")
+        offset += 4
+
+        # Extract request_id
+        request_id = chunk_data[offset : offset + id_length].decode("utf-8")
+        offset += id_length
+
+        # Extract chunk_index
+        chunk_index = int.from_bytes(
+            chunk_data[offset : offset + 4], byteorder="little"
+        )
+        offset += 4
+
+        # Extract total_chunks
+        total_chunks = int.from_bytes(
+            chunk_data[offset : offset + 4], byteorder="little"
+        )
+        offset += 4
+
+        # Extract body_chunk
+        body_chunk = chunk_data[offset:]
+
+        # Continue processing as before
+
+        if request_id in self.pending_requests:
+            request = self.pending_requests[request_id]
+            if "body_chunks" not in request:
+                request["body_chunks"] = {}
+                request["total_body_chunks"] = total_chunks
+            request["body_chunks"][chunk_index] = body_chunk
+            self.logger.debug(
+                f"Stored body chunk {chunk_index + 1}/{total_chunks} for request ID: {request_id}"
+            )
+            await self.check_and_process_request(websocket, request_id)
+        else:
+            self.logger.warning(
+                f"Received body chunk for unknown or completed request ID: {request_id}"
+            )
+
+    async def check_and_process_request(self, websocket, request_id):
+        request_data = self.pending_requests.get(request_id)
+        if request_data and request_data["metadata"]:
+            has_body = request_data["has_body"]
+            total_body_chunks = request_data.get("total_body_chunks", 0)
+            body_chunks = request_data.get("body_chunks", {})
+
+            all_chunks_received = not has_body or (
+                len(body_chunks) == total_body_chunks
+            )
+
+            if all_chunks_received:
+                # Ensure all chunks are present
+                for i in range(total_body_chunks):
+                    if i not in body_chunks:
+                        self.logger.error(
+                            f"Missing chunk {i + 1}/{total_body_chunks} for request ID: {request_id}"
+                        )
+                        return
+
+                self.logger.debug(f"Processing request ID: {request_id}")
+                await self.process_request(
+                    websocket, request_data["metadata"], body_chunks, request_id
+                )
+                del self.pending_requests[request_id]
+
+    async def process_request(
+        self, websocket, request_metadata, body_chunks, request_id
+    ):
+        self.logger.debug(
+            f"Processing request: {request_id} {request_metadata['method']} {request_metadata['url']}"
+        )
+
+        # Reassemble body if present
+        if request_metadata["has_body"]:
+            total_chunks = request_metadata["totalBodyChunks"]
+            body_data = b"".join(body_chunks[i] for i in range(total_chunks))
+        else:
+            body_data = None
+
+        # Parse the original URL to extract the path and query
+        parsed_url = urlparse(request_metadata["url"])
+        path_and_query = parsed_url.path
+        if parsed_url.query:
+            path_and_query += f"?{parsed_url.query}"
+
+        # Construct the new URL by appending path and query to destination_url
+        forward_url = self.destination_url + path_and_query
+
+        self.logger.debug(f"Forwarding request to: {forward_url}")
+
+        # Forward the request to the destination URL using urllib
+        try:
+            # Create a custom SSL context to ignore SSL verification (if needed)
+            ssl_context = ssl.create_default_context()
+            ssl_context.check_hostname = False
+            ssl_context.verify_mode = ssl.CERT_NONE
+
+            # Prepare the request
+            req = urllib.request.Request(
+                url=forward_url,
+                method=request_metadata["method"],
+                data=body_data if body_data else None,
+                headers=request_metadata["headers"],
+            )
+
+            # Make the request
+            with urllib.request.urlopen(req, context=ssl_context) as response:
+                response_body = response.read()
+                response_headers = dict(response.getheaders())
+                response_status = response.getcode()
+                self.logger.debug(
+                    f"Received response with status code: {response_status}"
+                )
+
+        except urllib.error.HTTPError as e:
+            # Non-200 status codes are here (even ones we want)
+            self.logger.debug(f"HTTPError forwarding request: {e}")
+            response_body = e.read()
+            response_headers = dict(e.headers)
+            response_status = e.code
+
+        except urllib.error.URLError as e:
+            self.logger.error(f"URLError forwarding request: {e}")
+            response_body = b""
+            response_headers = {}
+            response_status = 500
+
+        self.logger.info(
+            f"{click.style(request_metadata['method'], bold=True)} {request_metadata['url']} {response_status}"
+        )
+
+        has_body = len(response_body) > 0
+        max_chunk_size = 1000000  # 1,000,000 bytes
+        total_body_chunks = (
+            (len(response_body) + max_chunk_size - 1) // max_chunk_size
+            if has_body
+            else 0
+        )
+
+        response_metadata = {
+            "id": request_id,
+            "status": response_status,
+            "headers": list(response_headers.items()),
+            "has_body": has_body,
+            "totalBodyChunks": total_body_chunks,
+        }
+
+        # Send response metadata
+        response_metadata_json = json.dumps(response_metadata)
+        self.logger.debug(
+            f"Sending response metadata for ID: {request_id}, has_body: {has_body}"
+        )
+        await websocket.send(response_metadata_json)
+
+        # Send response body chunks if present
+        if has_body:
+            self.logger.debug(
+                f"Sending {total_body_chunks} body chunks for ID: {request_id}"
+            )
+            id_bytes = request_id.encode("utf-8")
+            for i in range(total_body_chunks):
+                chunk_start = i * max_chunk_size
+                chunk_end = min(chunk_start + max_chunk_size, len(response_body))
+                body_chunk = response_body[chunk_start:chunk_end]
+
+                # Prepare the binary message
+                chunk_index_bytes = i.to_bytes(4, byteorder="little")
+                total_chunks_bytes = total_body_chunks.to_bytes(4, byteorder="little")
+                message = id_bytes + chunk_index_bytes + total_chunks_bytes + body_chunk
+                await websocket.send(message)
+                self.logger.debug(
+                    f"Sent body chunk {i + 1}/{total_body_chunks} for ID: {request_id}"
+                )
+        else:
+            self.logger.debug(f"No body to send for ID: {request_id}")
+
+    async def shutdown(self):
+        self.stop_event.set()
+        tasks = [t for t in asyncio.all_tasks() if t is not asyncio.current_task()]
+        if tasks:
+            self.logger.debug(f"Cancelling {len(tasks)} outstanding tasks")
+            for task in tasks:
+                task.cancel()
+            await asyncio.gather(*tasks, return_exceptions=True)
+        await self.loop.shutdown_asyncgens()
+
+    def run(self):
+        try:
+            self.loop.run_until_complete(self.connect())
+        except KeyboardInterrupt:
+            self.logger.debug("Received exit signal")
+        finally:
+            self.logger.debug("Shutting down...")
+            self.loop.run_until_complete(self.shutdown())
+            self.loop.close()

plain_tunnel-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[tool.poetry]
+
+name = "plain.tunnel"
+packages = [
+    { include = "plain" },
+]
+
+version = "0.1.0"
+description = ""
+authors = ["Dave Gaeddert <dave.gaeddert@dropseed.dev>"]
+license = "BSD-3-Clause"
+readme = "README.md"
+homepage = "https://plainframework.com"
+documentation = "https://plainframework.com/docs/"
+repository = "https://github.com/dropseed/plain"
+
+# Make the CLI available without adding to INSTALLED_APPS
+[tool.poetry.plugins."plain.cli"]
+"tunnel" = "plain.tunnel:cli"
+
+[tool.poetry.dependencies]
+python = "^3.11"
+plain = "<1.0.0"
+click = ">=8.0.0"
+websockets = "*"
+
+[tool.poetry.group.dev.dependencies]
+plain = {path = "../plain", develop = true}
+
+[build-system]
+requires = ["poetry-core>=1.0.0"]
+build-backend = "poetry.core.masonry.api"