Break up websocket 2 (#17028)
* Break up websocket 2 * Lint+Test * Lintttt * Rename
This commit is contained in:
1 parent
b5e3d8c337
commit
2e6346ca43
27 files changed
+641
-568
No files matched your search
@@ -4,49 +4,18 @@ Websocket based API for Home Assistant.
|
||||
For more details about this component, please refer to the documentation at
|
||||
https://developers.home-assistant.io/docs/external_api_websocket.html
|
||||
"""
|
||||
import asyncio
|
||||
from concurrent import futures
|
||||
from contextlib import suppress
|
||||
from functools import partial
|
||||
import json
|
||||
import logging
|
||||
|
||||
from aiohttp import web
|
||||
import voluptuous as vol
|
||||
from voluptuous.humanize import humanize_error
|
||||
|
||||
from homeassistant.const import EVENT_HOMEASSISTANT_STOP, __version__
|
||||
from homeassistant.core import Context, callback
|
||||
from homeassistant.core import callback
|
||||
from homeassistant.loader import bind_hass
|
||||
from homeassistant.helpers.json import JSONEncoder
|
||||
from homeassistant.components.http import HomeAssistantView
|
||||
from homeassistant.components.http.auth import validate_password
|
||||
from homeassistant.components.http.const import KEY_AUTHENTICATED
|
||||
from homeassistant.components.http.ban import process_wrong_login, \
|
||||
process_success_login
|
||||
|
||||
from . import commands, const, decorators, messages
|
||||
from . import commands, connection, const, decorators, http, messages
|
||||
|
||||
DOMAIN = 'websocket_api'
|
||||
DOMAIN = const.DOMAIN
|
||||
|
||||
URL = '/api/websocket'
|
||||
DEPENDENCIES = ('http',)
|
||||
|
||||
MAX_PENDING_MSG = 512
|
||||
|
||||
|
||||
_LOGGER = logging.getLogger(__name__)
|
||||
|
||||
JSON_DUMP = partial(json.dumps, cls=JSONEncoder)
|
||||
|
||||
TYPE_AUTH = 'auth'
|
||||
TYPE_AUTH_INVALID = 'auth_invalid'
|
||||
TYPE_AUTH_OK = 'auth_ok'
|
||||
TYPE_AUTH_REQUIRED = 'auth_required'
|
||||
|
||||
|
||||
# Backwards compat
|
||||
# Backwards compat / Make it easier to integrate
|
||||
# pylint: disable=invalid-name
|
||||
ActiveConnection = connection.ActiveConnection
|
||||
BASE_COMMAND_MESSAGE_SCHEMA = messages.BASE_COMMAND_MESSAGE_SCHEMA
|
||||
error_message = messages.error_message
|
||||
result_message = messages.result_message
|
||||
@@ -54,42 +23,6 @@ async_response = decorators.async_response
|
||||
ws_require_user = decorators.ws_require_user
|
||||
# pylint: enable=invalid-name
|
||||
|
||||
AUTH_MESSAGE_SCHEMA = vol.Schema({
|
||||
vol.Required('type'): TYPE_AUTH,
|
||||
vol.Exclusive('api_password', 'auth'): str,
|
||||
vol.Exclusive('access_token', 'auth'): str,
|
||||
})
|
||||
|
||||
|
||||
# Define the possible errors that occur when connections are cancelled.
|
||||
# Originally, this was just asyncio.CancelledError, but issue #9546 showed
|
||||
# that futures.CancelledErrors can also occur in some situations.
|
||||
CANCELLATION_ERRORS = (asyncio.CancelledError, futures.CancelledError)
|
||||
|
||||
|
||||
def auth_ok_message():
|
||||
"""Return an auth_ok message."""
|
||||
return {
|
||||
'type': TYPE_AUTH_OK,
|
||||
'ha_version': __version__,
|
||||
}
|
||||
|
||||
|
||||
def auth_required_message():
|
||||
"""Return an auth_required message."""
|
||||
return {
|
||||
'type': TYPE_AUTH_REQUIRED,
|
||||
'ha_version': __version__,
|
||||
}
|
||||
|
||||
|
||||
def auth_invalid_message(message):
|
||||
"""Return an auth_invalid message."""
|
||||
return {
|
||||
'type': TYPE_AUTH_INVALID,
|
||||
'message': message,
|
||||
}
|
||||
|
||||
|
||||
@bind_hass
|
||||
@callback
|
||||
@@ -103,255 +36,6 @@ def async_register_command(hass, command, handler, schema):
|
||||
|
||||
async def async_setup(hass, config):
|
||||
"""Initialize the websocket API."""
|
||||
hass.http.register_view(WebsocketAPIView)
|
||||
hass.http.register_view(http.WebsocketAPIView)
|
||||
commands.async_register_commands(hass)
|
||||
return True
|
||||
|
||||
|
||||
class WebsocketAPIView(HomeAssistantView):
|
||||
"""View to serve a websockets endpoint."""
|
||||
|
||||
name = "websocketapi"
|
||||
url = URL
|
||||
requires_auth = False
|
||||
|
||||
async def get(self, request):
|
||||
"""Handle an incoming websocket connection."""
|
||||
return await ActiveConnection(request.app['hass'], request).handle()
|
||||
|
||||
|
||||
class ActiveConnection:
|
||||
"""Handle an active websocket client connection."""
|
||||
|
||||
def __init__(self, hass, request):
|
||||
"""Initialize an active connection."""
|
||||
self.hass = hass
|
||||
self.request = request
|
||||
self.wsock = None
|
||||
self.event_listeners = {}
|
||||
self.to_write = asyncio.Queue(maxsize=MAX_PENDING_MSG, loop=hass.loop)
|
||||
self._handle_task = None
|
||||
self._writer_task = None
|
||||
|
||||
@property
|
||||
def user(self):
|
||||
"""Return the user associated with the connection."""
|
||||
return self.request.get('hass_user')
|
||||
|
||||
def context(self, msg):
|
||||
"""Return a context."""
|
||||
user = self.user
|
||||
if user is None:
|
||||
return Context()
|
||||
return Context(user_id=user.id)
|
||||
|
||||
def debug(self, message1, message2=''):
|
||||
"""Print a debug message."""
|
||||
_LOGGER.debug("WS %s: %s %s", id(self.wsock), message1, message2)
|
||||
|
||||
def log_error(self, message1, message2=''):
|
||||
"""Print an error message."""
|
||||
_LOGGER.error("WS %s: %s %s", id(self.wsock), message1, message2)
|
||||
|
||||
async def _writer(self):
|
||||
"""Write outgoing messages."""
|
||||
# Exceptions if Socket disconnected or cancelled by connection handler
|
||||
with suppress(RuntimeError, *CANCELLATION_ERRORS):
|
||||
while not self.wsock.closed:
|
||||
message = await self.to_write.get()
|
||||
if message is None:
|
||||
break
|
||||
self.debug("Sending", message)
|
||||
try:
|
||||
await self.wsock.send_json(message, dumps=JSON_DUMP)
|
||||
except TypeError as err:
|
||||
_LOGGER.error('Unable to serialize to JSON: %s\n%s',
|
||||
err, message)
|
||||
|
||||
@callback
|
||||
def send_message_outside(self, message):
|
||||
"""Send a message to the client.
|
||||
|
||||
Closes connection if the client is not reading the messages.
|
||||
|
||||
Async friendly.
|
||||
"""
|
||||
try:
|
||||
self.to_write.put_nowait(message)
|
||||
except asyncio.QueueFull:
|
||||
self.log_error("Client exceeded max pending messages [2]:",
|
||||
MAX_PENDING_MSG)
|
||||
self.cancel()
|
||||
|
||||
@callback
|
||||
def cancel(self):
|
||||
"""Cancel the connection."""
|
||||
self._handle_task.cancel()
|
||||
self._writer_task.cancel()
|
||||
|
||||
async def handle(self):
|
||||
"""Handle the websocket connection."""
|
||||
request = self.request
|
||||
wsock = self.wsock = web.WebSocketResponse(heartbeat=55)
|
||||
await wsock.prepare(request)
|
||||
self.debug("Connected")
|
||||
|
||||
self._handle_task = asyncio.Task.current_task(loop=self.hass.loop)
|
||||
|
||||
@callback
|
||||
def handle_hass_stop(event):
|
||||
"""Cancel this connection."""
|
||||
self.cancel()
|
||||
|
||||
unsub_stop = self.hass.bus.async_listen(
|
||||
EVENT_HOMEASSISTANT_STOP, handle_hass_stop)
|
||||
self._writer_task = self.hass.async_add_job(self._writer())
|
||||
final_message = None
|
||||
msg = None
|
||||
authenticated = False
|
||||
|
||||
try:
|
||||
if request[KEY_AUTHENTICATED]:
|
||||
authenticated = True
|
||||
|
||||
# always request auth when auth is active
|
||||
# even request passed pre-authentication (trusted networks)
|
||||
# or when using legacy api_password
|
||||
if self.hass.auth.active or not authenticated:
|
||||
self.debug("Request auth")
|
||||
await self.wsock.send_json(auth_required_message())
|
||||
msg = await wsock.receive_json()
|
||||
msg = AUTH_MESSAGE_SCHEMA(msg)
|
||||
|
||||
if self.hass.auth.active and 'access_token' in msg:
|
||||
self.debug("Received access_token")
|
||||
refresh_token = \
|
||||
await self.hass.auth.async_validate_access_token(
|
||||
msg['access_token'])
|
||||
authenticated = refresh_token is not None
|
||||
if authenticated:
|
||||
request['hass_user'] = refresh_token.user
|
||||
request['refresh_token_id'] = refresh_token.id
|
||||
|
||||
elif ((not self.hass.auth.active or
|
||||
self.hass.auth.support_legacy) and
|
||||
'api_password' in msg):
|
||||
self.debug("Received api_password")
|
||||
authenticated = validate_password(
|
||||
request, msg['api_password'])
|
||||
|
||||
if not authenticated:
|
||||
self.debug("Authorization failed")
|
||||
await self.wsock.send_json(
|
||||
auth_invalid_message('Invalid access token or password'))
|
||||
await process_wrong_login(request)
|
||||
return wsock
|
||||
|
||||
self.debug("Auth OK")
|
||||
await process_success_login(request)
|
||||
await self.wsock.send_json(auth_ok_message())
|
||||
|
||||
# ---------- AUTH PHASE OVER ----------
|
||||
|
||||
msg = await wsock.receive_json()
|
||||
last_id = 0
|
||||
handlers = self.hass.data[DOMAIN]
|
||||
|
||||
while msg:
|
||||
self.debug("Received", msg)
|
||||
msg = messages.MINIMAL_MESSAGE_SCHEMA(msg)
|
||||
cur_id = msg['id']
|
||||
|
||||
if cur_id <= last_id:
|
||||
self.to_write.put_nowait(messages.error_message(
|
||||
cur_id, const.ERR_ID_REUSE,
|
||||
'Identifier values have to increase.'))
|
||||
|
||||
elif msg['type'] not in handlers:
|
||||
self.log_error(
|
||||
'Received invalid command: {}'.format(msg['type']))
|
||||
self.to_write.put_nowait(messages.error_message(
|
||||
cur_id, const.ERR_UNKNOWN_COMMAND,
|
||||
'Unknown command.'))
|
||||
|
||||
else:
|
||||
handler, schema = handlers[msg['type']]
|
||||
try:
|
||||
handler(self.hass, self, schema(msg))
|
||||
except Exception: # pylint: disable=broad-except
|
||||
_LOGGER.exception('Error handling message: %s', msg)
|
||||
self.to_write.put_nowait(messages.error_message(
|
||||
cur_id, const.ERR_UNKNOWN_ERROR,
|
||||
'Unknown error.'))
|
||||
|
||||
last_id = cur_id
|
||||
msg = await wsock.receive_json()
|
||||
|
||||
except vol.Invalid as err:
|
||||
error_msg = "Message incorrectly formatted: "
|
||||
if msg:
|
||||
error_msg += humanize_error(msg, err)
|
||||
else:
|
||||
error_msg += str(err)
|
||||
|
||||
self.log_error(error_msg)
|
||||
|
||||
if not authenticated:
|
||||
final_message = auth_invalid_message(error_msg)
|
||||
|
||||
else:
|
||||
if isinstance(msg, dict):
|
||||
iden = msg.get('id')
|
||||
else:
|
||||
iden = None
|
||||
|
||||
final_message = messages.error_message(
|
||||
iden, const.ERR_INVALID_FORMAT, error_msg)
|
||||
|
||||
except TypeError as err:
|
||||
if wsock.closed:
|
||||
self.debug("Connection closed by client")
|
||||
else:
|
||||
_LOGGER.exception("Unexpected TypeError: %s", err)
|
||||
|
||||
except ValueError as err:
|
||||
msg = "Received invalid JSON"
|
||||
value = getattr(err, 'doc', None) # Py3.5+ only
|
||||
if value:
|
||||
msg += ': {}'.format(value)
|
||||
self.log_error(msg)
|
||||
self._writer_task.cancel()
|
||||
|
||||
except CANCELLATION_ERRORS:
|
||||
self.debug("Connection cancelled")
|
||||
|
||||
except asyncio.QueueFull:
|
||||
self.log_error("Client exceeded max pending messages [1]:",
|
||||
MAX_PENDING_MSG)
|
||||
self._writer_task.cancel()
|
||||
|
||||
except Exception: # pylint: disable=broad-except
|
||||
error = "Unexpected error inside websocket API. "
|
||||
if msg is not None:
|
||||
error += str(msg)
|
||||
_LOGGER.exception(error)
|
||||
|
||||
finally:
|
||||
unsub_stop()
|
||||
|
||||
for unsub in self.event_listeners.values():
|
||||
unsub()
|
||||
|
||||
try:
|
||||
if final_message is not None:
|
||||
self.to_write.put_nowait(final_message)
|
||||
self.to_write.put_nowait(None)
|
||||
# Make sure all error messages are written before closing
|
||||
await self._writer_task
|
||||
except asyncio.QueueFull:
|
||||
self._writer_task.cancel()
|
||||
|
||||
await wsock.close()
|
||||
self.debug("Closed connection")
|
||||
|
||||
return wsock
|
||||
@@ -0,0 +1,99 @@
|
||||
"""Handle the auth of a connection."""
|
||||
import voluptuous as vol
|
||||
from voluptuous.humanize import humanize_error
|
||||
|
||||
from homeassistant.const import __version__
|
||||
from homeassistant.components.http.auth import validate_password
|
||||
from homeassistant.components.http.ban import process_wrong_login, \
|
||||
process_success_login
|
||||
|
||||
from .connection import ActiveConnection
|
||||
from .error import Disconnect
|
||||
|
||||
TYPE_AUTH = 'auth'
|
||||
TYPE_AUTH_INVALID = 'auth_invalid'
|
||||
TYPE_AUTH_OK = 'auth_ok'
|
||||
TYPE_AUTH_REQUIRED = 'auth_required'
|
||||
|
||||
AUTH_MESSAGE_SCHEMA = vol.Schema({
|
||||
vol.Required('type'): TYPE_AUTH,
|
||||
vol.Exclusive('api_password', 'auth'): str,
|
||||
vol.Exclusive('access_token', 'auth'): str,
|
||||
})
|
||||
|
||||
|
||||
def auth_ok_message():
|
||||
"""Return an auth_ok message."""
|
||||
return {
|
||||
'type': TYPE_AUTH_OK,
|
||||
'ha_version': __version__,
|
||||
}
|
||||
|
||||
|
||||
def auth_required_message():
|
||||
"""Return an auth_required message."""
|
||||
return {
|
||||
'type': TYPE_AUTH_REQUIRED,
|
||||
'ha_version': __version__,
|
||||
}
|
||||
|
||||
|
||||
def auth_invalid_message(message):
|
||||
"""Return an auth_invalid message."""
|
||||
return {
|
||||
'type': TYPE_AUTH_INVALID,
|
||||
'message': message,
|
||||
}
|
||||
|
||||
|
||||
class AuthPhase:
|
||||
"""Connection that requires client to authenticate first."""
|
||||
|
||||
def __init__(self, logger, hass, send_message, request):
|
||||
"""Initialize the authentiated connection."""
|
||||
self._hass = hass
|
||||
self._send_message = send_message
|
||||
self._logger = logger
|
||||
self._request = request
|
||||
self._authenticated = False
|
||||
self._connection = None
|
||||
|
||||
async def async_handle(self, msg):
|
||||
"""Handle authentication."""
|
||||
try:
|
||||
msg = AUTH_MESSAGE_SCHEMA(msg)
|
||||
except vol.Invalid as err:
|
||||
error_msg = 'Auth message incorrectly formatted: {}'.format(
|
||||
humanize_error(msg, err))
|
||||
self._logger.warning(error_msg)
|
||||
self._send_message(auth_invalid_message(error_msg))
|
||||
raise Disconnect
|
||||
|
||||
if self._hass.auth.active and 'access_token' in msg:
|
||||
self._logger.debug("Received access_token")
|
||||
refresh_token = \
|
||||
await self._hass.auth.async_validate_access_token(
|
||||
msg['access_token'])
|
||||
if refresh_token is not None:
|
||||
return await self._async_finish_auth(
|
||||
refresh_token.user, refresh_token)
|
||||
|
||||
elif ((not self._hass.auth.active or self._hass.auth.support_legacy)
|
||||
and 'api_password' in msg):
|
||||
self._logger.debug("Received api_password")
|
||||
if validate_password(self._request, msg['api_password']):
|
||||
return await self._async_finish_auth(None, None)
|
||||
|
||||
self._send_message(auth_invalid_message(
|
||||
'Invalid access token or password'))
|
||||
await process_wrong_login(self._request)
|
||||
raise Disconnect
|
||||
|
||||
async def _async_finish_auth(self, user, refresh_token) \
|
||||
-> ActiveConnection:
|
||||
"""Create an active connection."""
|
||||
self._logger.debug("Auth OK")
|
||||
await process_success_login(self._request)
|
||||
self._send_message(auth_ok_message())
|
||||
return ActiveConnection(
|
||||
self._logger, self._hass, self._send_message, user, refresh_token)
|
||||
@@ -103,12 +103,12 @@ def handle_subscribe_events(hass, connection, msg):
|
||||
if event.event_type == EVENT_TIME_CHANGED:
|
||||
return
|
||||
|
||||
connection.send_message_outside(event_message(msg['id'], event))
|
||||
connection.send_message(event_message(msg['id'], event))
|
||||
|
||||
connection.event_listeners[msg['id']] = hass.bus.async_listen(
|
||||
msg['event_type'], forward_events)
|
||||
|
||||
connection.to_write.put_nowait(messages.result_message(msg['id']))
|
||||
connection.send_message(messages.result_message(msg['id']))
|
||||
|
||||
|
||||
@callback
|
||||
@@ -121,9 +121,9 @@ def handle_unsubscribe_events(hass, connection, msg):
|
||||
|
||||
if subscription in connection.event_listeners:
|
||||
connection.event_listeners.pop(subscription)()
|
||||
connection.to_write.put_nowait(messages.result_message(msg['id']))
|
||||
connection.send_message(messages.result_message(msg['id']))
|
||||
else:
|
||||
connection.to_write.put_nowait(messages.error_message(
|
||||
connection.send_message(messages.error_message(
|
||||
msg['id'], const.ERR_NOT_FOUND, 'Subscription not found.'))
|
||||
|
||||
|
||||
@@ -140,7 +140,7 @@ async def handle_call_service(hass, connection, msg):
|
||||
await hass.services.async_call(
|
||||
msg['domain'], msg['service'], msg.get('service_data'), blocking,
|
||||
connection.context(msg))
|
||||
connection.send_message_outside(messages.result_message(msg['id']))
|
||||
connection.send_message(messages.result_message(msg['id']))
|
||||
|
||||
|
||||
@callback
|
||||
@@ -149,7 +149,7 @@ def handle_get_states(hass, connection, msg):
|
||||
|
||||
Async friendly.
|
||||
"""
|
||||
connection.to_write.put_nowait(messages.result_message(
|
||||
connection.send_message(messages.result_message(
|
||||
msg['id'], hass.states.async_all()))
|
||||
|
||||
|
||||
@@ -160,7 +160,7 @@ async def handle_get_services(hass, connection, msg):
|
||||
Async friendly.
|
||||
"""
|
||||
descriptions = await async_get_all_descriptions(hass)
|
||||
connection.send_message_outside(
|
||||
connection.send_message(
|
||||
messages.result_message(msg['id'], descriptions))
|
||||
|
||||
|
||||
@@ -170,7 +170,7 @@ def handle_get_config(hass, connection, msg):
|
||||
|
||||
Async friendly.
|
||||
"""
|
||||
connection.to_write.put_nowait(messages.result_message(
|
||||
connection.send_message(messages.result_message(
|
||||
msg['id'], hass.config.as_dict()))
|
||||
|
||||
|
||||
@@ -180,4 +180,4 @@ def handle_ping(hass, connection, msg):
|
||||
|
||||
Async friendly.
|
||||
"""
|
||||
connection.to_write.put_nowait(pong_message(msg['id']))
|
||||
connection.send_message(pong_message(msg['id']))
|
||||
@@ -0,0 +1,78 @@
|
||||
"""Connection session."""
|
||||
import voluptuous as vol
|
||||
|
||||
from homeassistant.core import callback, Context
|
||||
|
||||
from . import const, messages
|
||||
|
||||
|
||||
class ActiveConnection:
|
||||
"""Handle an active websocket client connection."""
|
||||
|
||||
def __init__(self, logger, hass, send_message, user, refresh_token):
|
||||
"""Initialize an active connection."""
|
||||
self.logger = logger
|
||||
self.hass = hass
|
||||
self.send_message = send_message
|
||||
self.user = user
|
||||
if refresh_token:
|
||||
self.refresh_token_id = refresh_token.id
|
||||
else:
|
||||
self.refresh_token_id = None
|
||||
|
||||
self.event_listeners = {}
|
||||
self.last_id = 0
|
||||
|
||||
def context(self, msg):
|
||||
"""Return a context."""
|
||||
user = self.user
|
||||
if user is None:
|
||||
return Context()
|
||||
return Context(user_id=user.id)
|
||||
|
||||
@callback
|
||||
def async_handle(self, msg):
|
||||
"""Handle a single incoming message."""
|
||||
handlers = self.hass.data[const.DOMAIN]
|
||||
|
||||
try:
|
||||
msg = messages.MINIMAL_MESSAGE_SCHEMA(msg)
|
||||
cur_id = msg['id']
|
||||
except vol.Invalid:
|
||||
self.logger.error('Received invalid command', msg)
|
||||
self.send_message(messages.error_message(
|
||||
msg.get('id'), const.ERR_INVALID_FORMAT,
|
||||
'Message incorrectly formatted.'))
|
||||
return
|
||||
|
||||
if cur_id <= self.last_id:
|
||||
self.send_message(messages.error_message(
|
||||
cur_id, const.ERR_ID_REUSE,
|
||||
'Identifier values have to increase.'))
|
||||
return
|
||||
|
||||
if msg['type'] not in handlers:
|
||||
self.logger.error(
|
||||
'Received invalid command: {}'.format(msg['type']))
|
||||
self.send_message(messages.error_message(
|
||||
cur_id, const.ERR_UNKNOWN_COMMAND,
|
||||
'Unknown command.'))
|
||||
return
|
||||
|
||||
handler, schema = handlers[msg['type']]
|
||||
|
||||
try:
|
||||
handler(self.hass, self, schema(msg))
|
||||
except Exception: # pylint: disable=broad-except
|
||||
self.logger.exception('Error handling message: %s', msg)
|
||||
self.send_message(messages.error_message(
|
||||
cur_id, const.ERR_UNKNOWN_ERROR,
|
||||
'Unknown error.'))
|
||||
|
||||
self.last_id = cur_id
|
||||
|
||||
@callback
|
||||
def async_close(self):
|
||||
"""Close down connection."""
|
||||
for unsub in self.event_listeners.values():
|
||||
unsub()
|
||||
@@ -1,4 +1,11 @@
|
||||
"""Websocket constants."""
|
||||
import asyncio
|
||||
from concurrent import futures
|
||||
|
||||
DOMAIN = 'websocket_api'
|
||||
URL = '/api/websocket'
|
||||
MAX_PENDING_MSG = 512
|
||||
|
||||
ERR_ID_REUSE = 1
|
||||
ERR_INVALID_FORMAT = 2
|
||||
ERR_NOT_FOUND = 3
|
||||
@@ -6,3 +13,8 @@ ERR_UNKNOWN_COMMAND = 4
|
||||
ERR_UNKNOWN_ERROR = 5
|
||||
|
||||
TYPE_RESULT = 'result'
|
||||
|
||||
# Define the possible errors that occur when connections are cancelled.
|
||||
# Originally, this was just asyncio.CancelledError, but issue #9546 showed
|
||||
# that futures.CancelledErrors can also occur in some situations.
|
||||
CANCELLATION_ERRORS = (asyncio.CancelledError, futures.CancelledError)
|
||||
@@ -18,7 +18,7 @@ def async_response(func):
|
||||
await func(hass, connection, msg)
|
||||
except Exception: # pylint: disable=broad-except
|
||||
_LOGGER.exception("Unexpected exception")
|
||||
connection.send_message_outside(messages.error_message(
|
||||
connection.send_message(messages.error_message(
|
||||
msg['id'], 'unknown', 'Unexpected error occurred'))
|
||||
|
||||
@callback
|
||||
@@ -35,10 +35,10 @@ def require_owner(func):
|
||||
@wraps(func)
|
||||
def with_owner(hass, connection, msg):
|
||||
"""Check owner and call function."""
|
||||
user = connection.request.get('hass_user')
|
||||
user = connection.user
|
||||
|
||||
if user is None or not user.is_owner:
|
||||
connection.to_write.put_nowait(messages.error_message(
|
||||
connection.send_message(messages.error_message(
|
||||
msg['id'], 'unauthorized', 'This command is for owners only.'))
|
||||
return
|
||||
|
||||
@@ -61,7 +61,7 @@ def ws_require_user(
|
||||
"""Check current user."""
|
||||
def output_error(message_id, message):
|
||||
"""Output error message."""
|
||||
connection.send_message_outside(messages.error_message(
|
||||
connection.send_message(messages.error_message(
|
||||
msg['id'], message_id, message))
|
||||
|
||||
if connection.user is None:
|
||||
|
||||
@@ -0,0 +1,8 @@
|
||||
"""WebSocket API related errors."""
|
||||
from homeassistant.exceptions import HomeAssistantError
|
||||
|
||||
|
||||
class Disconnect(HomeAssistantError):
|
||||
"""Disconnect the current session."""
|
||||
|
||||
pass
|
||||
@@ -0,0 +1,189 @@
|
||||
"""View to accept incoming websocket connection."""
|
||||
import asyncio
|
||||
from contextlib import suppress
|
||||
from functools import partial
|
||||
import json
|
||||
import logging
|
||||
|
||||
from aiohttp import web, WSMsgType
|
||||
import async_timeout
|
||||
|
||||
from homeassistant.const import EVENT_HOMEASSISTANT_STOP
|
||||
from homeassistant.core import callback
|
||||
from homeassistant.components.http import HomeAssistantView
|
||||
from homeassistant.helpers.json import JSONEncoder
|
||||
|
||||
from .const import MAX_PENDING_MSG, CANCELLATION_ERRORS, URL
|
||||
from .auth import AuthPhase, auth_required_message
|
||||
from .error import Disconnect
|
||||
|
||||
JSON_DUMP = partial(json.dumps, cls=JSONEncoder)
|
||||
|
||||
|
||||
class WebsocketAPIView(HomeAssistantView):
|
||||
"""View to serve a websockets endpoint."""
|
||||
|
||||
name = "websocketapi"
|
||||
url = URL
|
||||
requires_auth = False
|
||||
|
||||
async def get(self, request):
|
||||
"""Handle an incoming websocket connection."""
|
||||
return await WebSocketHandler(
|
||||
request.app['hass'], request).async_handle()
|
||||
|
||||
|
||||
class WebSocketHandler:
|
||||
"""Handle an active websocket client connection."""
|
||||
|
||||
def __init__(self, hass, request):
|
||||
"""Initialize an active connection."""
|
||||
self.hass = hass
|
||||
self.request = request
|
||||
self.wsock = None
|
||||
self._to_write = asyncio.Queue(maxsize=MAX_PENDING_MSG, loop=hass.loop)
|
||||
self._handle_task = None
|
||||
self._writer_task = None
|
||||
self._logger = logging.getLogger(
|
||||
"{}.connection.{}".format(__name__, id(self)))
|
||||
|
||||
async def _writer(self):
|
||||
"""Write outgoing messages."""
|
||||
# Exceptions if Socket disconnected or cancelled by connection handler
|
||||
with suppress(RuntimeError, *CANCELLATION_ERRORS):
|
||||
while not self.wsock.closed:
|
||||
message = await self._to_write.get()
|
||||
if message is None:
|
||||
break
|
||||
self._logger.debug("Sending %s", message)
|
||||
try:
|
||||
await self.wsock.send_json(message, dumps=JSON_DUMP)
|
||||
except TypeError as err:
|
||||
self._logger.error('Unable to serialize to JSON: %s\n%s',
|
||||
err, message)
|
||||
|
||||
@callback
|
||||
def _send_message(self, message):
|
||||
"""Send a message to the client.
|
||||
|
||||
Closes connection if the client is not reading the messages.
|
||||
|
||||
Async friendly.
|
||||
"""
|
||||
try:
|
||||
self._to_write.put_nowait(message)
|
||||
except asyncio.QueueFull:
|
||||
self._logger.error("Client exceeded max pending messages [2]: %s",
|
||||
MAX_PENDING_MSG)
|
||||
self._cancel()
|
||||
|
||||
@callback
|
||||
def _cancel(self):
|
||||
"""Cancel the connection."""
|
||||
self._handle_task.cancel()
|
||||
self._writer_task.cancel()
|
||||
|
||||
async def async_handle(self):
|
||||
"""Handle a websocket response."""
|
||||
request = self.request
|
||||
wsock = self.wsock = web.WebSocketResponse(heartbeat=55)
|
||||
await wsock.prepare(request)
|
||||
self._logger.debug("Connected")
|
||||
|
||||
# Py3.7+
|
||||
if hasattr(asyncio, 'current_task'):
|
||||
# pylint: disable=no-member
|
||||
self._handle_task = asyncio.current_task()
|
||||
else:
|
||||
self._handle_task = asyncio.Task.current_task(loop=self.hass.loop)
|
||||
|
||||
@callback
|
||||
def handle_hass_stop(event):
|
||||
"""Cancel this connection."""
|
||||
self._cancel()
|
||||
|
||||
unsub_stop = self.hass.bus.async_listen(
|
||||
EVENT_HOMEASSISTANT_STOP, handle_hass_stop)
|
||||
|
||||
self._writer_task = self.hass.async_create_task(self._writer())
|
||||
|
||||
auth = AuthPhase(self._logger, self.hass, self._send_message, request)
|
||||
connection = None
|
||||
disconnect_warn = None
|
||||
|
||||
try:
|
||||
self._send_message(auth_required_message())
|
||||
|
||||
# Auth Phase
|
||||
try:
|
||||
with async_timeout.timeout(10):
|
||||
msg = await wsock.receive()
|
||||
except asyncio.TimeoutError:
|
||||
disconnect_warn = \
|
||||
'Did not receive auth message within 10 seconds'
|
||||
raise Disconnect
|
||||
|
||||
if msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING):
|
||||
raise Disconnect
|
||||
|
||||
elif msg.type != WSMsgType.TEXT:
|
||||
disconnect_warn = 'Received non-Text message.'
|
||||
raise Disconnect
|
||||
|
||||
try:
|
||||
msg = msg.json()
|
||||
except ValueError:
|
||||
disconnect_warn = 'Received invalid JSON.'
|
||||
raise Disconnect
|
||||
|
||||
self._logger.debug("Received %s", msg)
|
||||
connection = await auth.async_handle(msg)
|
||||
|
||||
# Command phase
|
||||
while not wsock.closed:
|
||||
msg = await wsock.receive()
|
||||
|
||||
if msg.type in (WSMsgType.CLOSE, WSMsgType.CLOSING):
|
||||
break
|
||||
|
||||
elif msg.type != WSMsgType.TEXT:
|
||||
disconnect_warn = 'Received non-Text message.'
|
||||
break
|
||||
|
||||
try:
|
||||
msg = msg.json()
|
||||
except ValueError:
|
||||
disconnect_warn = 'Received invalid JSON.'
|
||||
break
|
||||
|
||||
self._logger.debug("Received %s", msg)
|
||||
connection.async_handle(msg)
|
||||
|
||||
except asyncio.CancelledError:
|
||||
self._logger.info("Connection closed by client")
|
||||
|
||||
except Disconnect:
|
||||
pass
|
||||
|
||||
except Exception: # pylint: disable=broad-except
|
||||
self._logger.exception("Unexpected error inside websocket API")
|
||||
|
||||
finally:
|
||||
unsub_stop()
|
||||
|
||||
if connection is not None:
|
||||
connection.async_close()
|
||||
|
||||
try:
|
||||
self._to_write.put_nowait(None)
|
||||
# Make sure all error messages are written before closing
|
||||
await self._writer_task
|
||||
except asyncio.QueueFull:
|
||||
self._writer_task.cancel()
|
||||
|
||||
await wsock.close()
|
||||
|
||||
if disconnect_warn is None:
|
||||
self._logger.debug("Disconnected")
|
||||
else:
|
||||
self._logger.warning("Disconnected: %s", disconnect_warn)
|
||||
Reference in new issue
Block a user