Bump UPC connect / fix auth issue (#26570)

* Bump UPC connect / fix auth issue

* Fix lint

* Fix platform schema

* Fix config value

* Address comment / add session cleanup

* Fix device handling
This commit is contained in:
Pascal Vizeli authored and GitHub committed 2019-09-11 13:17:07 +02:00
1 parent e6ecabd6e1
commit f3fa073045
8 files changed
+47 -321

No files matched your search

@@ -1,10 +1,9 @@
"""Support for UPC ConnectBox router."""
import asyncio
import logging
from typing import List, Optional
import aiohttp
from aiohttp.hdrs import REFERER, USER_AGENT
import async_timeout
from connect_box import ConnectBox
from connect_box.exceptions import ConnectBoxError, ConnectBoxLoginError
import voluptuous as vol
from homeassistant.components.device_tracker import (
@@ -12,118 +11,66 @@ from homeassistant.components.device_tracker import (
PLATFORM_SCHEMA,
DeviceScanner,
)
from homeassistant.const import CONF_HOST, HTTP_HEADER_X_REQUESTED_WITH
from homeassistant.helpers.aiohttp_client import async_get_clientsession
from homeassistant.const import CONF_HOST, CONF_PASSWORD, EVENT_HOMEASSISTANT_STOP
import homeassistant.helpers.config_validation as cv
_LOGGER = logging.getLogger(__name__)
CMD_DEVICES = 123
DEFAULT_IP = "192.168.0.1"
PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
{vol.Optional(CONF_HOST, default=DEFAULT_IP): cv.string}
{
vol.Required(CONF_PASSWORD): cv.string,
vol.Optional(CONF_HOST, default=DEFAULT_IP): cv.string,
}
)
async def async_get_scanner(hass, config):
"""Return the UPC device scanner."""
scanner = UPCDeviceScanner(hass, config[DOMAIN])
success_init = await scanner.async_initialize_token()
conf = config[DOMAIN]
session = hass.helpers.aiohttp_client.async_get_clientsession()
connect_box = ConnectBox(session, conf[CONF_PASSWORD], host=conf[CONF_HOST])
return scanner if success_init else None
# Check login data
try:
await connect_box.async_initialize_token()
except ConnectBoxLoginError:
_LOGGER.error("ConnectBox login data error!")
return None
except ConnectBoxError:
pass
async def _shutdown(event):
"""Shutdown event."""
await connect_box.async_close_session()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_STOP, _shutdown)
return UPCDeviceScanner(connect_box)
class UPCDeviceScanner(DeviceScanner):
"""This class queries a router running UPC ConnectBox firmware."""
def __init__(self, hass, config):
def __init__(self, connect_box: ConnectBox):
"""Initialize the scanner."""
self.hass = hass
self.host = config[CONF_HOST]
self.connect_box: ConnectBox = connect_box
self.data = {}
self.token = None
self.headers = {
HTTP_HEADER_X_REQUESTED_WITH: "XMLHttpRequest",
REFERER: f"http://{self.host}/index.html",
USER_AGENT: (
"Mozilla/5.0 (Windows NT 10.0; WOW64) "
"AppleWebKit/537.36 (KHTML, like Gecko) "
"Chrome/47.0.2526.106 Safari/537.36"
),
}
self.websession = async_get_clientsession(hass)
async def async_scan_devices(self):
async def async_scan_devices(self) -> List[str]:
"""Scan for new devices and return a list with found device IDs."""
import defusedxml.ElementTree as ET
if self.token is None:
token_initialized = await self.async_initialize_token()
if not token_initialized:
_LOGGER.error("Not connected to %s", self.host)
return []
raw = await self._async_ws_function(CMD_DEVICES)
try:
xml_root = ET.fromstring(raw)
return [mac.text for mac in xml_root.iter("MACAddr")]
except (ET.ParseError, TypeError):
_LOGGER.warning("Can't read device from %s", self.host)
self.token = None
await self.connect_box.async_get_devices()
except ConnectBoxError:
return []
async def async_get_device_name(self, device):
return [device.mac for device in self.connect_box.devices]
async def async_get_device_name(self, device: str) -> Optional[str]:
"""Get the device name (the name of the wireless device not used)."""
for connected_device in self.connect_box.devices:
if connected_device != device:
continue
return connected_device.hostname
return None
async def async_initialize_token(self):
"""Get first token."""
try:
# get first token
with async_timeout.timeout(10):
response = await self.websession.get(
f"http://{self.host}/common_page/login.html", headers=self.headers
)
await response.text()
self.token = response.cookies["sessionToken"].value
return True
except (asyncio.TimeoutError, aiohttp.ClientError):
_LOGGER.error("Can not load login page from %s", self.host)
return False
async def _async_ws_function(self, function):
"""Execute a command on UPC firmware webservice."""
try:
with async_timeout.timeout(10):
# The 'token' parameter has to be first, and 'fun' second
# or the UPC firmware will return an error
response = await self.websession.post(
f"http://{self.host}/xml/getter.xml",
data=f"token={self.token}&fun={function}",
headers=self.headers,
allow_redirects=False,
)
# Error?
if response.status != 200:
_LOGGER.warning("Receive http code %d", response.status)
self.token = None
return
# Load data, store token for next request
self.token = response.cookies["sessionToken"].value
return await response.text()
except (asyncio.TimeoutError, aiohttp.ClientError):
_LOGGER.error("Error on %s", function)
self.token = None
@@ -2,9 +2,7 @@
"domain": "upc_connect",
"name": "Upc connect",
"documentation": "https://www.home-assistant.io/components/upc_connect",
"requirements": [
"defusedxml==0.6.0"
],
"requirements": ["connect-box==0.2.3"],
"dependencies": [],
"codeowners": []
"codeowners": ["@pvizeli"]
}