implement all player ops + improve logging

aaronhnsy · aaronhnsy · commit 64d92a245215 · 2022-03-02T07:13:27.000Z
diff --git a/bot.py b/bot.py
@@ -40,7 +40,7 @@ async def on_ready(self) -> None:
             url=f'ws://{CONFIG["SERVER"]["host"]}:{CONFIG["SERVER"]["port"]}',
             headers={
                 'Authorization': CONFIG['SERVER']['password'],
-                'User-Agent':    'Python/3.10 swish.py/v0.0.1a',
+                'User-Agent':    'Python/v3.10.1,swish.py/v0.0.1a',
                 'User-Id':       str(self.user.id),
             },
         )
@@ -142,7 +142,7 @@ async def play(self, ctx: commands.Context, *, query: str) -> None:
 
         async with self.bot.session.get(
                 url='http://127.0.0.1:8000/search',
-                params={"query": query},
+                params={'query': query},
         ) as response:
 
             data = await response.json()
diff --git a/swish/app.py b/swish/app.py
@@ -15,6 +15,7 @@
 You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
+
 from __future__ import annotations
 
 import base64
@@ -52,8 +53,6 @@ def __init__(self):
 
     async def _run_app(self) -> None:
 
-        logger.debug('Starting Swish server...')
-
         runner = aiohttp.web.AppRunner(
             app=self
         )
@@ -74,7 +73,7 @@ async def _run_app(self) -> None:
     async def websocket_handler(self, request: aiohttp.web.Request) -> aiohttp.web.WebSocketResponse:
 
         # Initialise connection
-        logger.info(f'Incoming websocket connection request from "{request.remote}".')
+        logger.info(f'<{request.remote}> - Incoming websocket connection request.')
 
         websocket = aiohttp.web.WebSocketResponse()
         await websocket.prepare(request)
@@ -83,8 +82,8 @@ async def websocket_handler(self, request: aiohttp.web.Request) -> aiohttp.web.W
         user_agent = request.headers.get('User-Agent')
 
         if not user_agent:
-            logger.error(f'Websocket connection from "{request.remote}" failed due to missing User-Agent header.')
-            await websocket.close(code=4000, message=b'Missing "User-Agent" header.')
+            logger.error(f'<{request.remote}> - Websocket connection failed due to missing \'User-Agent\' header.')
+            await websocket.close(code=4000, message=b'Missing \'User-Agent\' header.')
             return websocket
 
         client_name = f'{user_agent} ({request.remote})'
@@ -93,15 +92,15 @@ async def websocket_handler(self, request: aiohttp.web.Request) -> aiohttp.web.W
         user_id = request.headers.get('User-Id')
 
         if not user_id:
-            logger.error(f'Websocket connection from "{request.remote}" failed due to missing User-Id header.')
-            await websocket.close(code=4000, message=b'Missing "User-Id" header.')
+            logger.error(f'<{client_name}> - Websocket connection failed due to missing \'User-Id\' header.')
+            await websocket.close(code=4000, message=b'Missing \'User-Id\' header.')
             return websocket
 
         # Authorization
         authorization = request.headers.get('Authorization')
 
         if CONFIG['SERVER']['password'] != authorization:
-            logger.error(f'Websocket connection from <{client_name}> failed due to mismatched Authorization header: {authorization}')
+            logger.error(f'<{client_name}> - Websocket connection failed due to mismatched \'Authorization\' header: {authorization}')
             await websocket.close(code=4001, message=b'Authorization failed.')
             return websocket
 
@@ -111,38 +110,35 @@ async def websocket_handler(self, request: aiohttp.web.Request) -> aiohttp.web.W
         websocket['user_id'] = user_id
         websocket['players'] = {}
 
-        logger.info(f'Websocket connection from <{client_name}> established.')
+        logger.info(f'<{client_name}> - Websocket connection established.')
 
         # Handle incoming messages
         async for message in websocket:  # type: aiohttp.WSMessage
 
             try:
                 payload = message.json()
-                logger.debug(f'Received payload from <{client_name}>.\nPayload: {payload}')
             except Exception:
-                logger.error(f'Received payload with invalid JSON format from <{client_name}>.\nPayload: {message.data}')
+                logger.error(f'<{client_name}> - Received payload with invalid JSON format.\nPayload: {message.data}')
                 continue
 
             if 'op' not in payload:
-                logger.error(f'Received payload with missing "op" key from <{client_name}>. Discarding.')
+                logger.error(f'<{client_name}> - Received payload with missing \'op\' key.\nPayload: {payload}')
                 continue
-
             if 'd' not in payload:
-                logger.error(f'Received payload with missing "d" key from <{client_name}>. Discarding.')
+                logger.error(f'<{client_name}> - Received payload with missing \'d\' key.\nPayload: {payload}')
                 continue
 
-            if not (guild_id := payload['d'].get('guild_id')):
-                logger.error(f'Received payload with missing "guild_id" data key from <{client_name}>. Discarding.')
+            if not (guild_id := payload['d'].get('guild_id', None)):
+                logger.error(f'<{client_name}> - Received payload with missing \'guild_id\' data key. Payload: {payload}')
                 continue
 
-            player: Player | None = websocket['players'].get(guild_id)
-            if not player:
+            if not (player := websocket['players'].get(guild_id)):  # type: Player | None
                 player = Player(self, websocket, guild_id, user_id)
                 websocket['players'][guild_id] = player
 
             await player.handle_payload(payload)
 
-        logger.info(f'Websocket connection from <{client_name}> closed.')
+        logger.info(f'<{client_name}> - Websocket connection closed.')
         return websocket
 
     # Rest handlers
@@ -196,7 +192,7 @@ async def _ytdl_search(self, query: str, internal: bool) -> Any:
     async def _get_playback_url(self, url: str) -> str:
 
         search = await self._ytdl_search(url, internal=True)
-        return search["url"]
+        return search['url']
 
     async def _get_tracks(self, query: str) -> list[dict[str, Any]]:
 
@@ -230,15 +226,15 @@ async def search_tracks(self, request: aiohttp.web.Request) -> aiohttp.web.Respo
 
         query = request.query.get('query')
         if not query:
-            return aiohttp.web.json_response({'error': 'Missing "query" query parameter.'}, status=400)
+            return aiohttp.web.json_response({'error': 'Missing \'query\' query parameter.'}, status=400)
 
         source = request.query.get('source', 'youtube')
         if (url := yarl.URL(query)) and url.host and url.scheme:
             source = 'none'
 
         prefix = self._SOURCE_MAPPING.get(source)
         if prefix is None:
-            return aiohttp.web.json_response({'error': 'Invalid "source" query parameter.'}, status=400)
+            return aiohttp.web.json_response({'error': 'Invalid \'source\' query parameter.'}, status=400)
 
         tracks = await self._get_tracks(f'{prefix}{query}')
 
diff --git a/swish/player.py b/swish/player.py
@@ -15,18 +15,20 @@
 You should have received a copy of the GNU Affero General Public License
 along with this program.  If not, see <http://www.gnu.org/licenses/>.
 """
+
 from __future__ import annotations
 
 import asyncio
 import logging
 from collections.abc import Awaitable, Callable
-from typing import TYPE_CHECKING, Any
+from typing import Any, TYPE_CHECKING
 
 import aiohttp
 import aiohttp.web
 from discord.backoff import ExponentialBackoff
 from discord.ext.native_voice import _native_voice
 
+
 if TYPE_CHECKING:
     from .app import App
 
@@ -50,69 +52,123 @@ def __init__(
         self._user_id: str = user_id
 
         self._connector: _native_voice.VoiceConnector = _native_voice.VoiceConnector()
+        self._connector.user_id = int(user_id)
+
         self._connection: _native_voice.VoiceConnection | None = None
         self._runner: asyncio.Task[None] | None = None
 
-        self._connector.user_id = int(user_id)
+        self._endpoint: str | None = None
 
-        self.OP_HANDLERS: dict[str, Callable[[dict[str, Any]], Awaitable[None]]] = {
-            'voice_update': self._voice_update,
-            'destroy': self._destroy,
-            'play': self._play,
-            'stop': self._stop,
+        self._OP_HANDLERS: dict[str, Callable[[dict[str, Any]], Awaitable[None]]] = {
+            'voice_update':    self._voice_update,
+            'destroy':         self._destroy,
+            'play':            self._play,
+            'stop':            self._stop,
             'set_pause_state': self._set_pause_state,
-            'set_position': self._set_position,
-            'set_filter': self._set_filter,
+            'set_position':    self._set_position,
+            'set_filter':      self._set_filter,
+            'debug':           self._debug,
         }
 
+        self._LOG_PREFIX: str = f'<{self._websocket["client_name"]}> - Player \'{self._guild_id}\''
+
+        self._NO_CONNECTION_MESSAGE: Callable[[str], str] = (
+            lambda op: f'{self._LOG_PREFIX} attempted \'{op}\' op while internal connection is down.'
+        )
+        self._MISSING_KEY_MESSAGE: Callable[[str, str], str] = (
+            lambda op, key: f'{self._LOG_PREFIX} received \'{op}\' op with missing \'{key}\' key.'
+        )
+
     # websocket op handlers
 
     async def handle_payload(self, payload: dict[str, Any]) -> None:
 
-        handler = self.OP_HANDLERS.get(payload['op'])
-        if not handler:
-            logger.error(f'Received payload with unknown "op" key from <{self._websocket["client_name"]}>. Discarding.')
+        op = payload['op']
+
+        if not (handler := self._OP_HANDLERS.get(op)):
+            logger.error(f'{self._LOG_PREFIX} received payload with unknown \'op\' key.\nPayload: {payload}')
             return
 
+        logger.debug(f'{self._LOG_PREFIX} received payload with \'{op}\' op.\nPayload: {payload}')
         await handler(payload['d'])
 
     async def _voice_update(self, data: dict[str, Any]) -> None:
 
         self._connector.session_id = data['session_id']
-        token = data['token']
-        guild_id = data['guild_id']
 
-        if (endpoint := data.get('endpoint')) is None:
+        if not (endpoint := data.get('endpoint')):
             return
 
         endpoint, _, _ = endpoint.rpartition(':')
         endpoint = endpoint.removeprefix('wss://')
+        self._endpoint = endpoint
 
-        self._connector.update_socket(token, guild_id, endpoint)
+        self._connector.update_socket(
+            data['token'],
+            data['guild_id'],
+            endpoint
+        )
         await self._connect()
 
-    async def _destroy(self, data: dict[str, Any]) -> None:
-        raise NotImplementedError
+    async def _destroy(self, _: dict[str, Any]) -> None:
+
+        await self._disconnect()
+        logger.info(f'{self._LOG_PREFIX} has been disconnected.')
 
     async def _play(self, data: dict[str, Any]) -> None:
 
-        info = self._app._decode_track_id(data['track_id'])
+        if not self._connection:
+            logger.error(self._NO_CONNECTION_MESSAGE('play'))
+            return
+
+        if not (track_id := data.get('track_id')):
+            logger.error(self._MISSING_KEY_MESSAGE('play', 'track_id'))
+            return
+
+        info = self._app._decode_track_id(track_id)
         url = await self._app._get_playback_url(info['url'])
 
-        if self._connection:
-            self._connection.play(url)
+        self._connection.play(url)
+        logger.info(f'{self._LOG_PREFIX} started playing track \'{info["title"]}\' by \'{info["author"]}\'.')
 
-    async def _stop(self, data: dict[str, Any]) -> None:
-        raise NotImplementedError
+    async def _stop(self, _: dict[str, Any]) -> None:
+
+        if not self._connection:
+            logger.error(self._NO_CONNECTION_MESSAGE('stop'))
+            return
+
+        self._connection.stop()
+        logger.info(f'{self._LOG_PREFIX} stopped the current track.')
 
     async def _set_pause_state(self, data: dict[str, Any]) -> None:
-        raise NotImplementedError
+
+        if not self._connection:
+            logger.error(self._NO_CONNECTION_MESSAGE('set_pause_state'))
+            return
+        if not (state := data.get('state')):
+            logger.error(self._MISSING_KEY_MESSAGE('set_pause_state', 'state'))
+            return
+
+        self._connection.pause() if state else self._connection.resume()
+        logger.info(f'{self._LOG_PREFIX} set its paused state to \'{state}\'.')
 
     async def _set_position(self, data: dict[str, Any]) -> None:
-        raise NotImplementedError
 
-    async def _set_filter(self, data: dict[str, Any]) -> None:
-        raise NotImplementedError
+        if not self._connection:
+            logger.error(self._NO_CONNECTION_MESSAGE('set_position'))
+            return
+        if not (position := data.get('position')):
+            logger.error(self._MISSING_KEY_MESSAGE('set_position', 'position'))
+            return
+
+        # TODO: implement
+        logger.info(f'{self._LOG_PREFIX} set its position to \'{position}\'.')
+
+    async def _set_filter(self, _: dict[str, Any]) -> None:
+        logger.error(f'{self._LOG_PREFIX} received \'set_filter\' op which is not yet implemented.')
+
+    async def _debug(self, _: dict[str, Any]) -> None:
+        print(self._debug_info())
 
     # internal connection handlers
 
@@ -126,6 +182,7 @@ async def _connect(self) -> None:
         self._runner = loop.create_task(self._reconnect_handler())
 
         self._websocket['players'][self._guild_id] = self
+        logger.info(f'{self._LOG_PREFIX} connected to internal voice server \'{self._endpoint}\'.')
 
     async def _reconnect_handler(self) -> None:
 
@@ -169,6 +226,7 @@ async def _disconnect(self) -> None:
         self._connection = None
 
         del self._websocket['players'][self._guild_id]
+        logger.info(f'{self._LOG_PREFIX} disconnected from internal voice server \'{self._endpoint}\'.')
 
     # utility
 
