Download data/copilotj/server/bridge.py from introvoyz045/CopilotJ: direct link, hf CLI and curl.
- Browser
- Download file 10.7 kB
-
https://huggingface.co/datasets/introvoyz045/CopilotJ/resolve/main/data/copilotj/server/bridge.py
- Command line
-
hf download hf://datasets/introvoyz045/CopilotJ/data/copilotj/server/bridge.py
-
curl -L -o bridge.py https://huggingface.co/datasets/introvoyz045/CopilotJ/resolve/main/data/copilotj/server/bridge.py
10.7 kB
| # SPDX-FileCopyrightText: Copyright contributors to the CopilotJ project. | |
| # | |
| # SPDX-License-Identifier: Apache-2.0 | |
| import asyncio | |
| import logging | |
| import uuid | |
| from datetime import datetime, timedelta | |
| from typing import Any | |
| import aiohttp | |
| import aiohttp.web as web | |
| import pydantic | |
| from copilotj.core.config import SINGLE_CLIENT_ID, is_single_client | |
| from copilotj.util import Base64ImageTruncator, IndentedRawJson | |
| __all__ = ["BridgeRequest", "BridgeResponse", "Bridge"] | |
| _log = logging.getLogger("copilotj.server.bridge") | |
| TEXT_MESSAGE_QUEUE_MAX_SIZE = 128 | |
| DEFAULT_TIMEOUT = 4 | |
| class _BridgeEvent(pydantic.BaseModel): | |
| id: uuid.UUID | |
| event_id: uuid.UUID | |
| event: str | |
| data: Any | None | |
| err: str | None | |
| class BridgeRequest(pydantic.BaseModel): | |
| client_id: uuid.UUID | |
| event: str | |
| data: Any | None = None | |
| timeout: float | None = None # seconds | |
| class BridgeResponse(pydantic.BaseModel): | |
| data: Any | None = None | |
| err: str | None = None | |
| class _IdChangedEventData(pydantic.BaseModel): | |
| id: uuid.UUID | |
| class _Client: | |
| def __init__(self, bridge: "Bridge") -> None: | |
| super().__init__() | |
| self.id = uuid.uuid4() | |
| self._bridge = bridge | |
| self._ws = web.WebSocketResponse() | |
| self._text_message_queue = asyncio.Queue[str](maxsize=TEXT_MESSAGE_QUEUE_MAX_SIZE) | |
| self._registered_events = dict[uuid.UUID, asyncio.Future[BridgeResponse]]() | |
| self._events_lock = asyncio.Lock() | |
| async def run(self, request: web.Request) -> web.StreamResponse: | |
| await self._ws.prepare(request) | |
| # Create a task to listen for messages from the queue and send them to the websocket | |
| async def websocket_sender(): | |
| try: | |
| while not self._ws.closed: | |
| message = await self._text_message_queue.get() | |
| if self._ws.closed: # FIXME: put the message back in the queue? | |
| break | |
| try: | |
| await self._ws.send_str(message) | |
| except Exception as e: | |
| _log.exception(f"Failed to send message to WebSocket: {e}") | |
| finally: | |
| self._text_message_queue.task_done() | |
| except asyncio.CancelledError: | |
| _log.info("WebSocket sender task cancelled") | |
| sender_task = asyncio.ensure_future(websocket_sender()) | |
| try: | |
| await self.on_message(self._ws) | |
| except Exception as e: | |
| _log.exception(e) | |
| finally: | |
| _log.info("Bridge WebSocket connection closed") | |
| await self._ws.close() | |
| # Cancel the sender task | |
| if not sender_task.done(): | |
| sender_task.cancel() | |
| try: | |
| await sender_task | |
| except asyncio.CancelledError: | |
| _log.info("Sender task cancelled") | |
| return self._ws | |
| async def on_message(self, ws: web.WebSocketResponse) -> None: | |
| async for msg in ws: | |
| match msg.type: | |
| case web.WSMsgType.TEXT: | |
| _log.debug("Received: %s", IndentedRawJson(Base64ImageTruncator(msg.data))) | |
| await self._on_message_text(msg) | |
| case web.WSMsgType.PING: | |
| await ws.pong() | |
| case web.WSMsgType.PONG: | |
| _log.debug("Received pong") | |
| case web.WSMsgType.CLOSE: | |
| _log.info("Received CLOSE") | |
| break | |
| case web.WSMsgType.ERROR: | |
| _log.info("ws connection closed with exception %s", ws.exception()) | |
| break | |
| case _: | |
| _log.error("Received non-recognized message: %s", msg.type) | |
| break | |
| async def send_event(self, event: str, data: Any, *, timeout: float = DEFAULT_TIMEOUT) -> BridgeResponse: | |
| # Create a future to track the response | |
| future = asyncio.get_event_loop().create_future() | |
| event_id = uuid.uuid4() | |
| async with self._events_lock: | |
| self._registered_events[event_id] = future | |
| try: | |
| payload = _BridgeEvent(id=uuid.uuid4(), event_id=event_id, event=event, data=data, err=None) | |
| await self._text_message_queue.put(payload.model_dump_json()) | |
| _log.debug("Sent event: %s (id: %s) with %s", event, event_id, data) | |
| # Wait for the response with timeout | |
| try: | |
| return await asyncio.wait_for(future, timeout=timeout) | |
| except asyncio.TimeoutError: | |
| _log.warning("Timeout waiting for response to event: %s (id: %s)", event, event_id) | |
| raise Exception(f"Timeout waiting for response to event: {event} (id: {event_id})") | |
| finally: | |
| # Clean up the registered event | |
| async with self._events_lock: | |
| self._registered_events.pop(event_id, None) | |
| async def close(self) -> None: | |
| await self._ws.close(code=aiohttp.WSCloseCode.GOING_AWAY, message=b"Server shutdown") | |
| async def _on_message_text(self, msg: aiohttp.WSMessage) -> None: | |
| try: | |
| # TODO: pref: streaming and partial validation | |
| response = _BridgeEvent.model_validate_json(msg.data) | |
| except Exception as e: | |
| _log.error(f"Failed to handle message: {e}") | |
| return | |
| # check if the event is registered | |
| event_id = response.event_id | |
| async with self._events_lock: | |
| if event_id not in self._registered_events: | |
| future = None | |
| else: | |
| future = self._registered_events[event_id] | |
| if future is None: | |
| return await self._on_event(response) | |
| if future.done(): | |
| _log.warning("Received event ID: %s (event: %s), but future is done", event_id, response.event) | |
| return | |
| _log.debug("Received unregistered event ID: %s (event: %s)", event_id, response.event) | |
| resp = BridgeResponse(data=response.data, err=response.err) | |
| future.set_result(resp) | |
| async def _on_event(self, response: _BridgeEvent) -> None: | |
| match response.event: | |
| case "query_id": | |
| data = _IdChangedEventData(id=self.id) | |
| payload = _BridgeEvent( | |
| id=uuid.uuid4(), event_id=response.event_id, event="id_changed", data=data, err=None | |
| ) | |
| await self._text_message_queue.put(payload.model_dump_json()) | |
| case "negotiate_id": | |
| event_data = _IdChangedEventData.model_validate(response.data) | |
| result = self._bridge._negotiate_id(self, event_data.id) | |
| if result is not None: | |
| err = result | |
| else: | |
| self.id = event_data.id | |
| err = None | |
| data = _IdChangedEventData(id=self.id) # always send the current id | |
| payload = _BridgeEvent( | |
| id=uuid.uuid4(), event_id=response.event_id, event="id_changed", data=data, err=err | |
| ) | |
| case _: | |
| _log.warning("Received unrecognized event: %s (id: %s)", response.event, response.id) | |
| return | |
| await self._text_message_queue.put(payload.model_dump_json()) | |
| class Bridge: | |
| def __init__(self) -> None: | |
| super().__init__() | |
| self._clients = dict[uuid.UUID, _Client]() | |
| self._close_event: asyncio.Event | None = None # TODO | |
| self._used_client_ids = dict[uuid.UUID, datetime]() | |
| async def on_plugin_connect(self, request: web.Request) -> web.StreamResponse: | |
| if is_single_client() and len(self._clients) > 0: | |
| _log.warning("Rejecting plugin connection: managed mode allows only one plugin") | |
| ws = web.WebSocketResponse() | |
| await ws.prepare(request) | |
| await ws.close(code=aiohttp.WSCloseCode.NOT_ACCEPTABLE, message=b"Managed mode: already connected") | |
| return ws | |
| client = _Client(self) | |
| self._clients[client.id] = client | |
| self._used_client_ids[client.id] = datetime.now() | |
| _log.info("Client WebSocket connection established: %s", client.id) | |
| ws = await client.run(request) | |
| self._clients.pop(client.id, None) | |
| return ws | |
| async def on_forward_event(self, request: web.Request) -> web.Response: | |
| """Handle forwarding events to ImageJ.""" | |
| try: | |
| # Parse request body | |
| body = await request.read() | |
| req = BridgeRequest.model_validate_json(body) | |
| resp = await self.send_event(req) | |
| state = 200 if resp.err is None else 500 | |
| except Exception as e: | |
| _log.error(f"Error forwarding event: {e}") | |
| resp = BridgeResponse(data=None, err=str(e)) | |
| state = 500 | |
| return web.Response(status=state, text=resp.model_dump_json(), content_type="application/json") | |
| async def send_event(self, req: BridgeRequest) -> BridgeResponse: | |
| client_id = req.client_id | |
| if client_id == SINGLE_CLIENT_ID and len(self._clients) > 0: | |
| client_id = next(iter(self._clients.keys())) # get the first client | |
| client = self._clients.get(client_id) | |
| if client is None: | |
| _log.error(f"Client not found: {req.client_id}") | |
| return BridgeResponse(err="Client not found") | |
| # Forward the event | |
| timeout = req.timeout or DEFAULT_TIMEOUT | |
| return await client.send_event(req.event, req.data, timeout=timeout) | |
| async def close(self) -> None: | |
| for _, c in self._clients.items(): | |
| await c.close() | |
| self._clients.clear() | |
| def _negotiate_id(self, client: _Client, new_id: uuid.UUID) -> str | None: | |
| if new_id == client.id: # not changed | |
| return None | |
| if ( | |
| new_id == SINGLE_CLIENT_ID # dev client id | |
| or new_id not in self._used_client_ids # not used | |
| or new_id in self._clients # already used | |
| or self._clients[client.id] != client # error from the client | |
| ): | |
| return "Client ID already used" | |
| # only allow changing the id if it was used in the last 24 hours | |
| if self._used_client_ids[new_id] - datetime.now() > timedelta(days=1): | |
| del self._used_client_ids[new_id] # remove the old id | |
| return "Client Id already used" | |
| self._used_client_ids[new_id] = datetime.now() # update the used id | |
| self._clients[new_id] = client # update the client id | |
| del self._clients[client.id] # remove the old client id | |
| return None | |