borecli 1.0.0__py3-none-any.whl

bore/parse_duration.py

@@ -0,0 +1,32 @@
+import re
+
+DEFAULT_TOKEN_LIFETIME = 3600
+
+
+def parse_duration(value: str) -> int:
+    """
+    Converts:
+        30m -> 1800
+        2h  -> 7200
+        1d  -> 86400
+        90s -> 90
+    """
+
+    match = re.fullmatch(r"(\d+)([smhd])", value.lower())
+
+    if not match:
+        raise ValueError(
+            "Time must look like 30m, 8h, 2d or 45s."
+        )
+
+    amount = int(match.group(1))
+    unit = match.group(2)
+
+    multipliers = {
+        "s": 1,
+        "m": 60,
+        "h": 3600,
+        "d": 86400,
+    }
+
+    return amount * multipliers[unit]

bore/protocol.py

@@ -0,0 +1,72 @@
+# borecli/bore/protocol.py
+
+
+PROTOCOL_VERSION = "borehook/1.0"
+
+
+
+class MessageType:
+    """
+    BoreHook tunnel protocol message types.
+    """
+
+
+    # =====================================================
+    # Tunnel lifecycle
+    # =====================================================
+
+    TUNNEL_REGISTER = "tunnel.register"
+
+    TUNNEL_STATUS = "tunnel.status"
+
+    TUNNEL_CLOSE = "tunnel.close"
+
+
+
+    # =====================================================
+    # HTTP tunneling
+    # =====================================================
+
+    HTTP_REQUEST = "http.request"
+
+    HTTP_RESPONSE = "http.response"
+
+    HTTP_RESPONSE_CHUNK = (
+        "http.response.chunk"
+    )
+
+
+
+    # =====================================================
+    # WebSocket tunneling
+    # =====================================================
+
+    WS_CONNECT = "ws.connect"
+
+    WS_CONNECTED = "ws.connected"
+
+    WS_MESSAGE = "ws.message"
+
+    WS_CLOSE = "ws.close"
+
+    WS_ERROR = "ws.error"
+
+
+
+    # =====================================================
+    # Heartbeat
+    # =====================================================
+
+    PING = "ping"
+
+    PONG = "pong"
+
+
+
+    # =====================================================
+    # System
+    # =====================================================
+
+    ERROR = "error"
+
+    METRICS = "metrics"

bore/tunnel/client.py

@@ -0,0 +1,311 @@
+# borecli/bore/tunnel/client.py
+
+import asyncio
+import logging
+
+import websockets
+
+from bore.frames import (receive_frame,send_frame,make_frame,)
+from bore.protocol import MessageType
+from bore.tunnel.dispatcher import ( MessageDispatcher,)
+from bore.tunnel.heartbeat import (Heartbeat,)
+logger = logging.getLogger(__name__)
+
+
+class TunnelClient:
+    """
+    BoreHook async tunnel client.
+
+    Handles:
+
+    - websocket lifecycle
+    - protocol receive loop
+    - dispatcher
+    - heartbeat
+    - reconnect
+    - graceful shutdown
+    """
+
+    def __init__(
+        self,
+        *,
+        ws_url: str,
+        local_port: int,
+        tunnel_id: str,
+        reconnect_delay: int = 5,
+    ):
+
+        self.ws_url = ws_url
+
+        self.local_port = local_port
+
+        self.tunnel_id = tunnel_id
+
+        self.reconnect_delay = reconnect_delay
+
+
+        self.websocket = None
+
+        self.heartbeat = None
+
+        self.dispatcher = None
+
+
+        self._shutdown = False
+
+        self._tasks = set()
+
+    async def _safe_dispatch(self, frame):
+                    try:
+                        await self.dispatcher.dispatch(frame)
+                    except asyncio.CancelledError:
+                        raise
+                    except Exception:
+                        logger.exception("Dispatcher crashed")
+
+    async def start(
+        self,
+        should_shutdown=lambda: False,
+    ):
+
+        """
+        Start tunnel forever.
+        """
+
+        while not self._shutdown:
+
+
+            if should_shutdown():
+
+                break
+
+
+            try:
+
+                await self._connect()
+
+
+                await self._receive_loop(
+                    should_shutdown
+                )
+
+
+            except asyncio.CancelledError:
+
+                break
+
+
+            except Exception:
+
+                logger.exception(
+                    "Tunnel connection failed"
+                )
+
+
+            finally:
+
+                await self._cleanup()
+
+
+
+            if self._shutdown:
+
+                break
+
+
+
+            if should_shutdown():
+
+                break
+
+
+
+            logger.info(
+                "Reconnecting in %s seconds",
+                self.reconnect_delay,
+            )
+
+
+            # await asyncio.sleep(
+            #     self.reconnect_delay
+            # )
+            for _ in range(self.reconnect_delay * 10):
+                if should_shutdown():
+                    return
+                await asyncio.sleep(0.1)
+
+
+    # async def stop(self):
+
+    #     self._shutdown = True
+
+    #     await self._cleanup()
+        
+    async def stop(self):
+        self._shutdown = True
+
+        if self.websocket:
+            await self.websocket.close()
+
+        await self._cleanup()
+
+
+
+    async def _connect(self):
+
+        logger.info(
+            "Connecting %s",
+            self.ws_url,
+        )
+
+
+        self.websocket = await websockets.connect(
+
+            self.ws_url,
+
+            ping_interval=None,
+
+            max_size=None,
+
+        )
+
+
+        logger.info(
+            "Tunnel websocket connected"
+        )
+
+
+        #
+        # Create dispatcher
+        #
+
+        self.heartbeat = Heartbeat(
+            self.websocket
+        )
+
+
+        self.dispatcher = MessageDispatcher(
+
+            websocket=self.websocket,
+
+            local_port=self.local_port,
+
+            heartbeat=self.heartbeat,
+
+        )
+        await self.heartbeat.start()
+
+
+
+    async def _receive_loop(
+        self,
+        should_shutdown,
+    ):
+
+
+        while True:
+
+
+            if self._shutdown:
+
+                break
+
+
+            if should_shutdown():
+
+                break
+
+
+            try:
+                frame = await asyncio.wait_for(
+                    receive_frame(self.websocket),
+                    timeout=1,
+                )
+            except asyncio.TimeoutError:
+                continue
+            # frame = await receive_frame(
+            #     self.websocket
+            # )
+
+
+            if frame is None:
+
+                break
+
+
+
+            # task = asyncio.create_task(
+
+            #     self.dispatcher.dispatch(
+            #         frame
+            #     )
+
+            # )
+
+            task = asyncio.create_task(
+                self._safe_dispatch(frame)
+            )
+            
+            self._tasks.add(task)
+
+
+            task.add_done_callback(
+                self._tasks.discard
+            )
+
+
+
+    async def _cleanup(self):
+
+
+        #
+        # cancel handlers
+        #
+        
+        for task in list(self._tasks):
+            task.cancel()
+
+        if self._tasks:
+            await asyncio.gather(
+                *self._tasks,
+                return_exceptions=True,
+            )
+
+        self._tasks.clear()
+        
+
+
+        #
+        # stop heartbeat
+        #
+
+        if self.heartbeat:
+
+
+            await self.heartbeat.stop()
+
+            self.heartbeat = None
+
+
+
+        #
+        # close websocket
+        #
+
+        if self.websocket:
+
+
+            try:
+
+                await self.websocket.close()
+
+
+            except Exception:
+
+                pass
+
+
+            self.websocket = None
+
+        logger.info("Cancelling %d tasks", len(self._tasks))
+        self.dispatcher = None

bore/tunnel/dispatcher.py

@@ -0,0 +1,277 @@
+# borecli/bore/tunnel/dispatcher.py
+
+import logging
+
+from bore.protocol import (
+    PROTOCOL_VERSION,
+    MessageType,
+)
+
+from bore.frames import (
+    send_frame,
+    make_frame,
+)
+
+from bore.handlers.http_handler import (
+    process_request,
+)
+
+from bore.handlers.websocket_handler import (
+    handle_ws_connect,
+    handle_ws_message,
+    handle_ws_close,
+)
+
+
+logger = logging.getLogger(__name__)
+
+
+class MessageDispatcher:
+    """
+    Routes BoreHook protocol frames.
+
+    The dispatcher does NOT:
+    - open connections
+    - forward HTTP
+    - manage websockets
+
+    It only decides who handles each frame.
+    """
+
+    def __init__(
+        self,
+        websocket,
+        local_port,
+        heartbeat,
+    ):
+
+        self.websocket = websocket
+
+        self.local_port = local_port
+
+        self.heartbeat = heartbeat
+
+
+    async def dispatch(
+        self,
+        frame: dict,
+    ):
+
+        #
+        # Validate protocol
+        #
+
+        protocol = frame.get(
+            "protocol"
+        )
+
+        if protocol != PROTOCOL_VERSION:
+
+            logger.warning(
+                "Unsupported protocol: %s",
+                protocol,
+            )
+
+            return
+
+
+        message_type = frame.get(
+            "type"
+        )
+
+
+        if not message_type:
+
+            logger.warning(
+                "Frame missing type"
+            )
+
+            return
+
+
+        logger.debug(
+            "Dispatching %s",
+            message_type,
+        )
+
+
+        #
+        # -----------------------------
+        # HTTP
+        # -----------------------------
+        #
+
+        # if message_type == MessageType.HTTP_REQUEST:
+
+
+        #     await process_request(
+
+        #         websocket=self.websocket,
+
+        #         local_port=self.local_port,
+
+        #         frame=frame,
+
+        #     )
+
+        #     return
+        
+        if message_type == MessageType.HTTP_REQUEST:
+            try:
+                await process_request(
+                    websocket=self.websocket,
+                    local_port=self.local_port,
+                    frame=frame,
+                )
+            except Exception:
+                logger.exception("Failed to process HTTP request")
+            return
+
+
+
+        #
+        # -----------------------------
+        # WebSocket
+        # -----------------------------
+        #
+
+        if message_type == MessageType.WS_CONNECT:
+
+
+            await handle_ws_connect(
+
+                websocket=self.websocket,
+
+                local_port=self.local_port,
+
+                frame=frame,
+
+            )
+
+            return
+
+
+
+        if message_type == MessageType.WS_MESSAGE:
+
+
+            await handle_ws_message(
+
+                frame=frame,
+
+            )
+
+            return
+
+
+
+        if message_type == MessageType.WS_CLOSE:
+
+
+            await handle_ws_close(
+
+                frame=frame,
+
+            )
+
+            return
+
+
+
+        #
+        # -----------------------------
+        # Heartbeat
+        # -----------------------------
+        #
+
+        if message_type == MessageType.PING:
+
+
+            await send_frame(
+
+                self.websocket,
+
+                make_frame(
+
+                    MessageType.PONG
+
+                )
+
+            )
+
+            return
+
+
+
+        if message_type == MessageType.PONG:
+
+
+            if self.heartbeat:
+
+                self.heartbeat.pong()
+
+
+            return
+
+
+
+        #
+        # -----------------------------
+        # Server messages
+        # -----------------------------
+        #
+
+        if message_type == MessageType.ERROR:
+
+
+            logger.error(
+
+                "Server error: %s",
+
+                frame.get(
+                    "message",
+                    "Unknown error",
+                )
+
+            )
+
+            return
+
+
+
+        if message_type == MessageType.TUNNEL_STATUS:
+
+
+            logger.info(
+
+                "Tunnel status: %s",
+
+                frame.get(
+                    "status"
+                )
+
+            )
+
+            return
+
+
+
+        if message_type == MessageType.METRICS:
+
+
+            logger.debug(
+                "Metrics received: %s",
+                frame,
+            )
+
+            return
+
+
+
+        logger.warning(
+
+            "Unknown message type: %s",
+
+            message_type,
+
+        )