evlli/hass-core
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #2063 from home-assistant/feature/wsgi

Browse source 
Feature/wsgi
This commit is contained in:
Paulus Schoutsen 2016-05-21 15:14:12 -07:00
commit 0b4b46d80b
50 changed files with 1242 additions and 1231 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

124
homeassistant/components/alexa.py
View file

@ -7,14 +7,14 @@ https://home-assistant.io/components/alexa/
import enum
import logging
from homeassistant.const import HTTP_OK, HTTP_UNPROCESSABLE_ENTITY
from homeassistant.const import HTTP_BAD_REQUEST
from homeassistant.helpers import template, script
from homeassistant.components.http import HomeAssistantView
DOMAIN = 'alexa'
DEPENDENCIES = ['http']
_LOGGER = logging.getLogger(__name__)
_CONFIG = {}
API_ENDPOINT = '/api/alexa'
@ -26,80 +26,88 @@ CONF_ACTION = 'action'
def setup(hass, config):
"""Activate Alexa component."""
intents = config[DOMAIN].get(CONF_INTENTS, {})
for name, intent in intents.items():
if CONF_ACTION in intent:
intent[CONF_ACTION] = script.Script(hass, intent[CONF_ACTION],
"Alexa intent {}".format(name))
_CONFIG.update(intents)
hass.http.register_path('POST', API_ENDPOINT, _handle_alexa, True)
hass.wsgi.register_view(AlexaView(hass,
config[DOMAIN].get(CONF_INTENTS, {})))
return True
def _handle_alexa(handler, path_match, data):
"""Handle Alexa."""
_LOGGER.debug('Received Alexa request: %s', data)
class AlexaView(HomeAssistantView):
"""Handle Alexa requests."""
req = data.get('request')
url = API_ENDPOINT
name = 'api:alexa'
if req is None:
_LOGGER.error('Received invalid data from Alexa: %s', data)
handler.write_json_message(
"Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY)
return
def __init__(self, hass, intents):
"""Initialize Alexa view."""
super().__init__(hass)
req_type = req['type']
for name, intent in intents.items():
if CONF_ACTION in intent:
intent[CONF_ACTION] = script.Script(
hass, intent[CONF_ACTION], "Alexa intent {}".format(name))
if req_type == 'SessionEndedRequest':
handler.send_response(HTTP_OK)
handler.end_headers()
return
self.intents = intents
intent = req.get('intent')
response = AlexaResponse(handler.server.hass, intent)
def post(self, request):
"""Handle Alexa."""
data = request.json
if req_type == 'LaunchRequest':
response.add_speech(
SpeechType.plaintext,
"Hello, and welcome to the future. How may I help?")
handler.write_json(response.as_dict())
return
_LOGGER.debug('Received Alexa request: %s', data)
if req_type != 'IntentRequest':
_LOGGER.warning('Received unsupported request: %s', req_type)
return
req = data.get('request')
intent_name = intent['name']
config = _CONFIG.get(intent_name)
if req is None:
_LOGGER.error('Received invalid data from Alexa: %s', data)
return self.json_message('Expected request value not received',
HTTP_BAD_REQUEST)
if config is None:
_LOGGER.warning('Received unknown intent %s', intent_name)
response.add_speech(
SpeechType.plaintext,
"This intent is not yet configured within Home Assistant.")
handler.write_json(response.as_dict())
return
req_type = req['type']
speech = config.get(CONF_SPEECH)
card = config.get(CONF_CARD)
action = config.get(CONF_ACTION)
if req_type == 'SessionEndedRequest':
return None
# pylint: disable=unsubscriptable-object
if speech is not None:
response.add_speech(SpeechType[speech['type']], speech['text'])
intent = req.get('intent')
response = AlexaResponse(self.hass, intent)
if card is not None:
response.add_card(CardType[card['type']], card['title'],
card['content'])
if req_type == 'LaunchRequest':
response.add_speech(
SpeechType.plaintext,
"Hello, and welcome to the future. How may I help?")
return self.json(response)
if action is not None:
action.run(response.variables)
if req_type != 'IntentRequest':
_LOGGER.warning('Received unsupported request: %s', req_type)
return self.json_message(
'Received unsupported request: {}'.format(req_type),
HTTP_BAD_REQUEST)
handler.write_json(response.as_dict())
intent_name = intent['name']
config = self.intents.get(intent_name)
if config is None:
_LOGGER.warning('Received unknown intent %s', intent_name)
response.add_speech(
SpeechType.plaintext,
"This intent is not yet configured within Home Assistant.")
return self.json(response)
speech = config.get(CONF_SPEECH)
card = config.get(CONF_CARD)
action = config.get(CONF_ACTION)
# pylint: disable=unsubscriptable-object
if speech is not None:
response.add_speech(SpeechType[speech['type']], speech['text'])
if card is not None:
response.add_card(CardType[card['type']], card['title'],
card['content'])
if action is not None:
action.run(response.variables)
return self.json(response)
class SpeechType(enum.Enum):

573
homeassistant/components/api.py
View file

@ -6,23 +6,23 @@ https://home-assistant.io/developers/api/
"""
import json
import logging
import re
import threading
from time import time
import homeassistant.core as ha
import homeassistant.remote as rem
from homeassistant.bootstrap import ERROR_LOG_FILENAME
from homeassistant.const import (
CONTENT_TYPE_TEXT_PLAIN, EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_HEADER_CONTENT_TYPE, HTTP_NOT_FOUND,
HTTP_OK, HTTP_UNPROCESSABLE_ENTITY, MATCH_ALL, URL_API, URL_API_COMPONENTS,
EVENT_HOMEASSISTANT_STOP, EVENT_TIME_CHANGED,
HTTP_BAD_REQUEST, HTTP_CREATED, HTTP_NOT_FOUND,
HTTP_UNPROCESSABLE_ENTITY, MATCH_ALL, URL_API, URL_API_COMPONENTS,
URL_API_CONFIG, URL_API_DISCOVERY_INFO, URL_API_ERROR_LOG,
URL_API_EVENT_FORWARD, URL_API_EVENTS, URL_API_LOG_OUT, URL_API_SERVICES,
URL_API_EVENT_FORWARD, URL_API_EVENTS, URL_API_SERVICES,
URL_API_STATES, URL_API_STATES_ENTITY, URL_API_STREAM, URL_API_TEMPLATE,
__version__)
from homeassistant.exceptions import TemplateError
from homeassistant.helpers.state import TrackStates
from homeassistant.helpers import template
from homeassistant.components.http import HomeAssistantView
DOMAIN = 'api'
DEPENDENCIES = ['http']
@ -35,372 +35,369 @@ _LOGGER = logging.getLogger(__name__)
def setup(hass, config):
"""Register the API with the HTTP interface."""
# /api - for validation purposes
hass.http.register_path('GET', URL_API, _handle_get_api)
# /api/config
hass.http.register_path('GET', URL_API_CONFIG, _handle_get_api_config)
# /api/discovery_info
hass.http.register_path('GET', URL_API_DISCOVERY_INFO,
_handle_get_api_discovery_info,
require_auth=False)
# /api/stream
hass.http.register_path('GET', URL_API_STREAM, _handle_get_api_stream)
# /api/states
hass.http.register_path('GET', URL_API_STATES, _handle_get_api_states)
hass.http.register_path(
'GET', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
_handle_get_api_states_entity)
hass.http.register_path(
'POST', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
_handle_post_state_entity)
hass.http.register_path(
'PUT', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
_handle_post_state_entity)
hass.http.register_path(
'DELETE', re.compile(r'/api/states/(?P<entity_id>[a-zA-Z\._0-9]+)'),
_handle_delete_state_entity)
# /api/events
hass.http.register_path('GET', URL_API_EVENTS, _handle_get_api_events)
hass.http.register_path(
'POST', re.compile(r'/api/events/(?P<event_type>[a-zA-Z\._0-9]+)'),
_handle_api_post_events_event)
# /api/services
hass.http.register_path('GET', URL_API_SERVICES, _handle_get_api_services)
hass.http.register_path(
'POST',
re.compile((r'/api/services/'
r'(?P<domain>[a-zA-Z\._0-9]+)/'
r'(?P<service>[a-zA-Z\._0-9]+)')),
_handle_post_api_services_domain_service)
# /api/event_forwarding
hass.http.register_path(
'POST', URL_API_EVENT_FORWARD, _handle_post_api_event_forward)
hass.http.register_path(
'DELETE', URL_API_EVENT_FORWARD, _handle_delete_api_event_forward)
# /api/components
hass.http.register_path(
'GET', URL_API_COMPONENTS, _handle_get_api_components)
# /api/error_log
hass.http.register_path('GET', URL_API_ERROR_LOG,
_handle_get_api_error_log)
hass.http.register_path('POST', URL_API_LOG_OUT, _handle_post_api_log_out)
# /api/template
hass.http.register_path('POST', URL_API_TEMPLATE,
_handle_post_api_template)
hass.wsgi.register_view(APIStatusView)
hass.wsgi.register_view(APIEventStream)
hass.wsgi.register_view(APIConfigView)
hass.wsgi.register_view(APIDiscoveryView)
hass.wsgi.register_view(APIStatesView)
hass.wsgi.register_view(APIEntityStateView)
hass.wsgi.register_view(APIEventListenersView)
hass.wsgi.register_view(APIEventView)
hass.wsgi.register_view(APIServicesView)
hass.wsgi.register_view(APIDomainServicesView)
hass.wsgi.register_view(APIEventForwardingView)
hass.wsgi.register_view(APIComponentsView)
hass.wsgi.register_view(APIErrorLogView)
hass.wsgi.register_view(APITemplateView)
return True
def _handle_get_api(handler, path_match, data):
"""Render the debug interface."""
handler.write_json_message("API running.")
def _handle_get_api_stream(handler, path_match, data):
"""Provide a streaming interface for the event bus."""
gracefully_closed = False
hass = handler.server.hass
wfile = handler.wfile
write_lock = threading.Lock()
block = threading.Event()
session_id = None
class APIStatusView(HomeAssistantView):
"""View to handle Status requests."""
restrict = data.get('restrict')
if restrict:
restrict = restrict.split(',')
url = URL_API
name = "api:status"
def write_message(payload):
"""Write a message to the output."""
with write_lock:
msg = "data: {}\n\n".format(payload)
def get(self, request):
"""Retrieve if API is running."""
return self.json_message('API running.')
try:
wfile.write(msg.encode("UTF-8"))
wfile.flush()
except (IOError, ValueError):
# IOError: socket errors
# ValueError: raised when 'I/O operation on closed file'
block.set()
def forward_events(event):
"""Forward events to the open request."""
nonlocal gracefully_closed
class APIEventStream(HomeAssistantView):
"""View to handle EventStream requests."""
if block.is_set() or event.event_type == EVENT_TIME_CHANGED:
return
elif event.event_type == EVENT_HOMEASSISTANT_STOP:
gracefully_closed = True
block.set()
return
url = URL_API_STREAM
name = "api:stream"
def get(self, request):
"""Provide a streaming interface for the event bus."""
from eventlet.queue import LightQueue, Empty
import eventlet
handler.server.sessions.extend_validation(session_id)
write_message(json.dumps(event, cls=rem.JSONEncoder))
cur_hub = eventlet.hubs.get_hub()
request.environ['eventlet.minimum_write_chunk_size'] = 0
to_write = LightQueue()
stop_obj = object()
handler.send_response(HTTP_OK)
handler.send_header('Content-type', 'text/event-stream')
session_id = handler.set_session_cookie_header()
handler.end_headers()
restrict = request.args.get('restrict')
if restrict:
restrict = restrict.split(',')
if restrict:
for event in restrict:
hass.bus.listen(event, forward_events)
else:
hass.bus.listen(MATCH_ALL, forward_events)
def thread_forward_events(event):
"""Forward events to the open request."""
if event.event_type == EVENT_TIME_CHANGED:
return
while True:
write_message(STREAM_PING_PAYLOAD)
_LOGGER.debug('STREAM %s FORWARDING %s', id(stop_obj), event)
block.wait(STREAM_PING_INTERVAL)
if event.event_type == EVENT_HOMEASSISTANT_STOP:
data = stop_obj
else:
data = json.dumps(event, cls=rem.JSONEncoder)
if block.is_set():
break
cur_hub.schedule_call_global(0, lambda: to_write.put(data))
if not gracefully_closed:
_LOGGER.info("Found broken event stream to %s, cleaning up",
handler.client_address[0])
def stream():
"""Stream events to response."""
if restrict:
for event_type in restrict:
self.hass.bus.listen(event_type, thread_forward_events)
else:
self.hass.bus.listen(MATCH_ALL, thread_forward_events)
_LOGGER.debug('STREAM %s ATTACHED', id(stop_obj))
if restrict:
for event in restrict:
hass.bus.remove_listener(event, forward_events)
else:
hass.bus.remove_listener(MATCH_ALL, forward_events)
last_msg = time()
while True:
try:
# Somehow our queue.get takes too long to
# be notified of arrival of object. Probably
# because of our spawning on hub in other thread
# hack. Because current goal is to get this out,
# We just timeout every second because it will
# return right away if qsize() > 0.
# So yes, we're basically polling :(
# socket.io anyone?
payload = to_write.get(timeout=1)
def _handle_get_api_config(handler, path_match, data):
"""Return the Home Assistant configuration."""
handler.write_json(handler.server.hass.config.as_dict())
if payload is stop_obj:
break
msg = "data: {}\n\n".format(payload)
_LOGGER.debug('STREAM %s WRITING %s', id(stop_obj),
msg.strip())
yield msg.encode("UTF-8")
last_msg = time()
except Empty:
if time() - last_msg > 50:
to_write.put(STREAM_PING_PAYLOAD)
except GeneratorExit:
_LOGGER.debug('STREAM %s RESPONSE CLOSED', id(stop_obj))
break
def _handle_get_api_discovery_info(handler, path_match, data):
needs_auth = (handler.server.hass.config.api.api_password is not None)
params = {
'base_url': handler.server.hass.config.api.base_url,
'location_name': handler.server.hass.config.location_name,
'requires_api_password': needs_auth,
'version': __version__
}
handler.write_json(params)
if restrict:
for event in restrict:
self.hass.bus.remove_listener(event, thread_forward_events)
else:
self.hass.bus.remove_listener(MATCH_ALL, thread_forward_events)
return self.Response(stream(), mimetype='text/event-stream')
def _handle_get_api_states(handler, path_match, data):
"""Return a dict containing all entity ids and their state."""
handler.write_json(handler.server.hass.states.all())
class APIConfigView(HomeAssistantView):
"""View to handle Config requests."""
def _handle_get_api_states_entity(handler, path_match, data):
"""Return the state of a specific entity."""
entity_id = path_match.group('entity_id')
url = URL_API_CONFIG
name = "api:config"
state = handler.server.hass.states.get(entity_id)
def get(self, request):
"""Get current configuration."""
return self.json(self.hass.config.as_dict())
if state:
handler.write_json(state)
else:
handler.write_json_message("State does not exist.", HTTP_NOT_FOUND)
class APIDiscoveryView(HomeAssistantView):
"""View to provide discovery info."""
def _handle_post_state_entity(handler, path_match, data):
"""Handle updating the state of an entity.
requires_auth = False
url = URL_API_DISCOVERY_INFO
name = "api:discovery"
This handles the following paths:
/api/states/<entity_id>
"""
entity_id = path_match.group('entity_id')
def get(self, request):
"""Get discovery info."""
needs_auth = self.hass.config.api.api_password is not None
return self.json({
'base_url': self.hass.config.api.base_url,
'location_name': self.hass.config.location_name,
'requires_api_password': needs_auth,
'version': __version__
})
try:
new_state = data['state']
except KeyError:
handler.write_json_message("state not specified", HTTP_BAD_REQUEST)
return
attributes = data['attributes'] if 'attributes' in data else None
class APIStatesView(HomeAssistantView):
"""View to handle States requests."""
is_new_state = handler.server.hass.states.get(entity_id) is None
url = URL_API_STATES
name = "api:states"
# Write state
handler.server.hass.states.set(entity_id, new_state, attributes)
def get(self, request):
"""Get current states."""
return self.json(self.hass.states.all())
state = handler.server.hass.states.get(entity_id)
status_code = HTTP_CREATED if is_new_state else HTTP_OK
class APIEntityStateView(HomeAssistantView):
"""View to handle EntityState requests."""
handler.write_json(
state.as_dict(),
status_code=status_code,
location=URL_API_STATES_ENTITY.format(entity_id))
url = "/api/states/<entity(exist=False):entity_id>"
name = "api:entity-state"
def get(self, request, entity_id):
"""Retrieve state of entity."""
state = self.hass.states.get(entity_id)
if state:
return self.json(state)
else:
return self.json_message('Entity not found', HTTP_NOT_FOUND)
def _handle_delete_state_entity(handler, path_match, data):
"""Handle request to delete an entity from state machine.
def post(self, request, entity_id):
"""Update state of entity."""
try:
new_state = request.json['state']
except KeyError:
return self.json_message('No state specified', HTTP_BAD_REQUEST)
This handles the following paths:
/api/states/<entity_id>
"""
entity_id = path_match.group('entity_id')
attributes = request.json.get('attributes')
if handler.server.hass.states.remove(entity_id):
handler.write_json_message(
"Entity not found", HTTP_NOT_FOUND)
else:
handler.write_json_message(
"Entity removed", HTTP_OK)
is_new_state = self.hass.states.get(entity_id) is None
# Write state
self.hass.states.set(entity_id, new_state, attributes)
def _handle_get_api_events(handler, path_match, data):
"""Handle getting overview of event listeners."""
handler.write_json(events_json(handler.server.hass))
# Read the state back for our response
resp = self.json(self.hass.states.get(entity_id))
if is_new_state:
resp.status_code = HTTP_CREATED
def _handle_api_post_events_event(handler, path_match, event_data):
"""Handle firing of an event.
resp.headers.add('Location', URL_API_STATES_ENTITY.format(entity_id))
This handles the following paths: /api/events/<event_type>
return resp
Events from /api are threated as remote events.
"""
event_type = path_match.group('event_type')
def delete(self, request, entity_id):
"""Remove entity."""
if self.hass.states.remove(entity_id):
return self.json_message('Entity removed')
else:
return self.json_message('Entity not found', HTTP_NOT_FOUND)
if event_data is not None and not isinstance(event_data, dict):
handler.write_json_message(
"event_data should be an object", HTTP_UNPROCESSABLE_ENTITY)
return
event_origin = ha.EventOrigin.remote
class APIEventListenersView(HomeAssistantView):
"""View to handle EventListeners requests."""
# Special case handling for event STATE_CHANGED
# We will try to convert state dicts back to State objects
if event_type == ha.EVENT_STATE_CHANGED and event_data:
for key in ('old_state', 'new_state'):
state = ha.State.from_dict(event_data.get(key))
url = URL_API_EVENTS
name = "api:event-listeners"
if state:
event_data[key] = state
def get(self, request):
"""Get event listeners."""
return self.json(events_json(self.hass))
handler.server.hass.bus.fire(event_type, event_data, event_origin)
handler.write_json_message("Event {} fired.".format(event_type))
class APIEventView(HomeAssistantView):
"""View to handle Event requests."""
url = '/api/events/<event_type>'
name = "api:event"
def _handle_get_api_services(handler, path_match, data):
"""Handle getting overview of services."""
handler.write_json(services_json(handler.server.hass))
def post(self, request, event_type):
"""Fire events."""
event_data = request.json
if event_data is not None and not isinstance(event_data, dict):
return self.json_message('Event data should be a JSON object',
HTTP_BAD_REQUEST)
# pylint: disable=invalid-name
def _handle_post_api_services_domain_service(handler, path_match, data):
"""Handle calling a service.
# Special case handling for event STATE_CHANGED
# We will try to convert state dicts back to State objects
if event_type == ha.EVENT_STATE_CHANGED and event_data:
for key in ('old_state', 'new_state'):
state = ha.State.from_dict(event_data.get(key))
This handles the following paths: /api/services/<domain>/<service>
"""
domain = path_match.group('domain')
service = path_match.group('service')
if state:
event_data[key] = state
with TrackStates(handler.server.hass) as changed_states:
handler.server.hass.services.call(domain, service, data, True)
self.hass.bus.fire(event_type, event_data, ha.EventOrigin.remote)
handler.write_json(changed_states)
return self.json_message("Event {} fired.".format(event_type))
# pylint: disable=invalid-name
def _handle_post_api_event_forward(handler, path_match, data):
"""Handle adding an event forwarding target."""
try:
host = data['host']
api_password = data['api_password']
except KeyError:
handler.write_json_message(
"No host or api_password received.", HTTP_BAD_REQUEST)
return
class APIServicesView(HomeAssistantView):
"""View to handle Services requests."""
try:
port = int(data['port']) if 'port' in data else None
except ValueError:
handler.write_json_message(
"Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY)
return
url = URL_API_SERVICES
name = "api:services"
api = rem.API(host, api_password, port)
def get(self, request):
"""Get registered services."""
return self.json(services_json(self.hass))
if not api.validate_api():
handler.write_json_message(
"Unable to validate API", HTTP_UNPROCESSABLE_ENTITY)
return
if handler.server.event_forwarder is None:
handler.server.event_forwarder = \
rem.EventForwarder(handler.server.hass)
class APIDomainServicesView(HomeAssistantView):
"""View to handle DomainServices requests."""
handler.server.event_forwarder.connect(api)
url = "/api/services/<domain>/<service>"
name = "api:domain-services"
handler.write_json_message("Event forwarding setup.")
def post(self, request, domain, service):
"""Call a service.
Returns a list of changed states.
"""
with TrackStates(self.hass) as changed_states:
self.hass.services.call(domain, service, request.json, True)
def _handle_delete_api_event_forward(handler, path_match, data):
"""Handle deleting an event forwarding target."""
try:
host = data['host']
except KeyError:
handler.write_json_message("No host received.", HTTP_BAD_REQUEST)
return
return self.json(changed_states)
try:
port = int(data['port']) if 'port' in data else None
except ValueError:
handler.write_json_message(
"Invalid value received for port", HTTP_UNPROCESSABLE_ENTITY)
return
if handler.server.event_forwarder is not None:
api = rem.API(host, None, port)
class APIEventForwardingView(HomeAssistantView):
"""View to handle EventForwarding requests."""
handler.server.event_forwarder.disconnect(api)
url = URL_API_EVENT_FORWARD
name = "api:event-forward"
event_forwarder = None
handler.write_json_message("Event forwarding cancelled.")
def post(self, request):
"""Setup an event forwarder."""
data = request.json
if data is None:
return self.json_message("No data received.", HTTP_BAD_REQUEST)
try:
host = data['host']
api_password = data['api_password']
except KeyError:
return self.json_message("No host or api_password received.",
HTTP_BAD_REQUEST)
try:
port = int(data['port']) if 'port' in data else None
except ValueError:
return self.json_message("Invalid value received for port.",
HTTP_UNPROCESSABLE_ENTITY)
def _handle_get_api_components(handler, path_match, data):
"""Return all the loaded components."""
handler.write_json(handler.server.hass.config.components)
api = rem.API(host, api_password, port)
if not api.validate_api():
return self.json_message("Unable to validate API.",
HTTP_UNPROCESSABLE_ENTITY)
def _handle_get_api_error_log(handler, path_match, data):
"""Return the logged errors for this session."""
handler.write_file(handler.server.hass.config.path(ERROR_LOG_FILENAME),
False)
if self.event_forwarder is None:
self.event_forwarder = rem.EventForwarder(self.hass)
self.event_forwarder.connect(api)
def _handle_post_api_log_out(handler, path_match, data):
"""Log user out."""
handler.send_response(HTTP_OK)
handler.destroy_session()
handler.end_headers()
return self.json_message("Event forwarding setup.")
def delete(self, request):
"""Remove event forwarer."""
data = request.json
if data is None:
return self.json_message("No data received.", HTTP_BAD_REQUEST)
def _handle_post_api_template(handler, path_match, data):
"""Log user out."""
template_string = data.get('template', '')
try:
host = data['host']
except KeyError:
return self.json_message("No host received.", HTTP_BAD_REQUEST)
try:
rendered = template.render(handler.server.hass, template_string)
try:
port = int(data['port']) if 'port' in data else None
except ValueError:
return self.json_message("Invalid value received for port.",
HTTP_UNPROCESSABLE_ENTITY)
handler.send_response(HTTP_OK)
handler.send_header(HTTP_HEADER_CONTENT_TYPE, CONTENT_TYPE_TEXT_PLAIN)
handler.end_headers()
handler.wfile.write(rendered.encode('utf-8'))
except TemplateError as e:
handler.write_json_message(str(e), HTTP_UNPROCESSABLE_ENTITY)
return
if self.event_forwarder is not None:
api = rem.API(host, None, port)
self.event_forwarder.disconnect(api)
return self.json_message("Event forwarding cancelled.")
class APIComponentsView(HomeAssistantView):
"""View to handle Components requests."""
url = URL_API_COMPONENTS
name = "api:components"
def get(self, request):
"""Get current loaded components."""
return self.json(self.hass.config.components)
class APIErrorLogView(HomeAssistantView):
"""View to handle ErrorLog requests."""
url = URL_API_ERROR_LOG
name = "api:error-log"
def get(self, request):
"""Serve error log."""
return self.file(request, self.hass.config.path(ERROR_LOG_FILENAME))
class APITemplateView(HomeAssistantView):
"""View to handle requests."""
url = URL_API_TEMPLATE
name = "api:template"
def post(self, request):
"""Render a template."""
try:
return template.render(self.hass, request.json['template'],
request.json.get('variables'))
except TemplateError as ex:
return self.json_message('Error rendering template: {}'.format(ex),
HTTP_BAD_REQUEST)
def services_json(hass):

171
homeassistant/components/camera/__init__.py
View file

@ -6,17 +6,12 @@ For more details about this component, please refer to the documentation at
https://home-assistant.io/components/camera/
"""
import logging
import re
import time
import requests
from homeassistant.helpers.entity import Entity
from homeassistant.helpers.entity_component import EntityComponent
from homeassistant.components import bloomsky
from homeassistant.const import HTTP_OK, HTTP_NOT_FOUND, ATTR_ENTITY_ID
from homeassistant.helpers.config_validation import PLATFORM_SCHEMA # noqa
from homeassistant.components.http import HomeAssistantView
DOMAIN = 'camera'
DEPENDENCIES = ['http']
@ -34,9 +29,6 @@ STATE_IDLE = 'idle'
ENTITY_IMAGE_URL = '/api/camera_proxy/{0}'
MULTIPART_BOUNDARY = '--jpgboundary'
MJPEG_START_HEADER = 'Content-type: {0}\r\n\r\n'
# pylint: disable=too-many-branches
def setup(hass, config):
@ -45,57 +37,11 @@ def setup(hass, config):
logging.getLogger(__name__), DOMAIN, hass, SCAN_INTERVAL,
DISCOVERY_PLATFORMS)
hass.wsgi.register_view(CameraImageView(hass, component.entities))
hass.wsgi.register_view(CameraMjpegStream(hass, component.entities))
component.setup(config)
def _proxy_camera_image(handler, path_match, data):
"""Serve the camera image via the HA server."""
entity_id = path_match.group(ATTR_ENTITY_ID)
camera = component.entities.get(entity_id)
if camera is None:
handler.send_response(HTTP_NOT_FOUND)
handler.end_headers()
return
response = camera.camera_image()
if response is None:
handler.send_response(HTTP_NOT_FOUND)
handler.end_headers()
return
handler.send_response(HTTP_OK)
handler.write_content(response)
hass.http.register_path(
'GET',
re.compile(r'/api/camera_proxy/(?P<entity_id>[a-zA-Z\._0-9]+)'),
_proxy_camera_image)
def _proxy_camera_mjpeg_stream(handler, path_match, data):
"""Proxy the camera image as an mjpeg stream via the HA server."""
entity_id = path_match.group(ATTR_ENTITY_ID)
camera = component.entities.get(entity_id)
if camera is None:
handler.send_response(HTTP_NOT_FOUND)
handler.end_headers()
return
try:
camera.is_streaming = True
camera.update_ha_state()
camera.mjpeg_stream(handler)
except (requests.RequestException, IOError):
camera.is_streaming = False
camera.update_ha_state()
hass.http.register_path(
'GET',
re.compile(r'/api/camera_proxy_stream/(?P<entity_id>[a-zA-Z\._0-9]+)'),
_proxy_camera_mjpeg_stream)
return True
@ -106,6 +52,11 @@ class Camera(Entity):
"""Initialize a camera."""
self.is_streaming = False
@property
def access_token(self):
"""Access token for this camera."""
return str(id(self))
@property
def should_poll(self):
"""No need to poll cameras."""
@ -135,32 +86,35 @@ class Camera(Entity):
"""Return bytes of camera image."""
raise NotImplementedError()
def mjpeg_stream(self, handler):
def mjpeg_stream(self, response):
"""Generate an HTTP MJPEG stream from camera images."""
def write_string(text):
"""Helper method to write a string to the stream."""
handler.request.sendall(bytes(text + '\r\n', 'utf-8'))
import eventlet
response.content_type = ('multipart/x-mixed-replace; '
'boundary=--jpegboundary')
write_string('HTTP/1.1 200 OK')
write_string('Content-type: multipart/x-mixed-replace; '
'boundary={}'.format(MULTIPART_BOUNDARY))
write_string('')
write_string(MULTIPART_BOUNDARY)
def stream():
"""Stream images as mjpeg stream."""
try:
last_image = None
while True:
img_bytes = self.camera_image()
while True:
img_bytes = self.camera_image()
if img_bytes is not None and img_bytes != last_image:
yield bytes(
'--jpegboundary\r\n'
'Content-Type: image/jpeg\r\n'
'Content-Length: {}\r\n\r\n'.format(
len(img_bytes)), 'utf-8') + img_bytes + b'\r\n'
if img_bytes is None:
continue
last_image = img_bytes
write_string('Content-length: {}'.format(len(img_bytes)))
write_string('Content-type: image/jpeg')
write_string('')
handler.request.sendall(img_bytes)
write_string('')
write_string(MULTIPART_BOUNDARY)
eventlet.sleep(0.5)
except GeneratorExit:
pass
time.sleep(0.5)
response.response = stream()
return response
@property
def state(self):
@ -175,7 +129,9 @@ class Camera(Entity):
@property
def state_attributes(self):
"""Camera state attributes."""
attr = {}
attr = {
'access_token': self.access_token,
}
if self.model:
attr['model_name'] = self.model
@ -184,3 +140,60 @@ class Camera(Entity):
attr['brand'] = self.brand
return attr
class CameraView(HomeAssistantView):
"""Base CameraView."""
requires_auth = False
def __init__(self, hass, entities):
"""Initialize a basic camera view."""
super().__init__(hass)
self.entities = entities
def get(self, request, entity_id):
"""Start a get request."""
camera = self.entities.get(entity_id)
if camera is None:
return self.Response(status=404)
authenticated = (request.authenticated or
request.args.get('token') == camera.access_token)
if not authenticated:
return self.Response(status=401)
return self.handle(camera)
def handle(self, camera):
"""Hanlde the camera request."""
raise NotImplementedError()
class CameraImageView(CameraView):
"""Camera view to serve an image."""
url = "/api/camera_proxy/<entity(domain=camera):entity_id>"
name = "api:camera:image"
def handle(self, camera):
"""Serve camera image."""
response = camera.camera_image()
if response is None:
return self.Response(status=500)
return self.Response(response)
class CameraMjpegStream(CameraView):
"""Camera View to serve an MJPEG stream."""
url = "/api/camera_proxy_stream/<entity(domain=camera):entity_id>"
name = "api:camera:stream"
def handle(self, camera):
"""Serve camera image."""
return camera.mjpeg_stream(self.Response())

18
homeassistant/components/camera/mjpeg.py
View file

@ -11,7 +11,6 @@ import requests
from requests.auth import HTTPBasicAuth
from homeassistant.components.camera import DOMAIN, Camera
from homeassistant.const import HTTP_OK
from homeassistant.helpers import validate_config
CONTENT_TYPE_HEADER = 'Content-Type'
@ -68,19 +67,12 @@ class MjpegCamera(Camera):
with closing(self.camera_stream()) as response:
return process_response(response)
def mjpeg_stream(self, handler):
def mjpeg_stream(self, response):
"""Generate an HTTP MJPEG stream from the camera."""
response = self.camera_stream()
content_type = response.headers[CONTENT_TYPE_HEADER]
handler.send_response(HTTP_OK)
handler.send_header(CONTENT_TYPE_HEADER, content_type)
handler.end_headers()
for chunk in response.iter_content(chunk_size=1024):
if not chunk:
break
handler.wfile.write(chunk)
stream = self.camera_stream()
response.mimetype = stream.headers[CONTENT_TYPE_HEADER]
response.response = stream.iter_content(chunk_size=1024)
return response
@property
def name(self):

141
homeassistant/components/device_tracker/locative.py
View file

@ -5,95 +5,92 @@ For more details about this platform, please refer to the documentation at
https://home-assistant.io/components/device_tracker.locative/
"""
import logging
from functools import partial
from homeassistant.components.device_tracker import DOMAIN
from homeassistant.const import HTTP_UNPROCESSABLE_ENTITY, STATE_NOT_HOME
from homeassistant.components.http import HomeAssistantView
_LOGGER = logging.getLogger(__name__)
DEPENDENCIES = ['http']
URL_API_LOCATIVE_ENDPOINT = "/api/locative"
def setup_scanner(hass, config, see):
"""Setup an endpoint for the Locative application."""
# POST would be semantically better, but that currently does not work
# since Locative sends the data as key1=value1&key2=value2
# in the request body, while Home Assistant expects json there.
hass.http.register_path(
'GET', URL_API_LOCATIVE_ENDPOINT,
partial(_handle_get_api_locative, hass, see))
hass.wsgi.register_view(LocativeView(hass, see))
return True
def _handle_get_api_locative(hass, see, handler, path_match, data):
"""Locative message received."""
if not _check_data(handler, data):
return
class LocativeView(HomeAssistantView):
"""View to handle locative requests."""
device = data['device'].replace('-', '')
location_name = data['id'].lower()
direction = data['trigger']
url = "/api/locative"
name = "api:bootstrap"
if direction == 'enter':
see(dev_id=device, location_name=location_name)
handler.write_text("Setting location to {}".format(location_name))
def __init__(self, hass, see):
"""Initialize Locative url endpoints."""
super().__init__(hass)
self.see = see
elif direction == 'exit':
current_state = hass.states.get("{}.{}".format(DOMAIN, device))
def get(self, request):
"""Locative message received as GET."""
return self.post(request)
def post(self, request):
"""Locative message received."""
# pylint: disable=too-many-return-statements
data = request.values
if 'latitude' not in data or 'longitude' not in data:
return ("Latitude and longitude not specified.",
HTTP_UNPROCESSABLE_ENTITY)
if 'device' not in data:
_LOGGER.error("Device id not specified.")
return ("Device id not specified.",
HTTP_UNPROCESSABLE_ENTITY)
if 'id' not in data:
_LOGGER.error("Location id not specified.")
return ("Location id not specified.",
HTTP_UNPROCESSABLE_ENTITY)
if 'trigger' not in data:
_LOGGER.error("Trigger is not specified.")
return ("Trigger is not specified.",
HTTP_UNPROCESSABLE_ENTITY)
device = data['device'].replace('-', '')
location_name = data['id'].lower()
direction = data['trigger']
if direction == 'enter':
self.see(dev_id=device, location_name=location_name)
return "Setting location to {}".format(location_name)
elif direction == 'exit':
current_state = self.hass.states.get(
"{}.{}".format(DOMAIN, device))
if current_state is None or current_state.state == location_name:
self.see(dev_id=device, location_name=STATE_NOT_HOME)
return "Setting location to not home"
else:
# Ignore the message if it is telling us to exit a zone that we
# aren't currently in. This occurs when a zone is entered
# before the previous zone was exited. The enter message will
# be sent first, then the exit message will be sent second.
return 'Ignoring exit from {} (already in {})'.format(
location_name, current_state)
elif direction == 'test':
# In the app, a test message can be sent. Just return something to
# the user to let them know that it works.
return "Received test message."
if current_state is None or current_state.state == location_name:
see(dev_id=device, location_name=STATE_NOT_HOME)
handler.write_text("Setting location to not home")
else:
# Ignore the message if it is telling us to exit a zone that we
# aren't currently in. This occurs when a zone is entered before
# the previous zone was exited. The enter message will be sent
# first, then the exit message will be sent second.
handler.write_text(
'Ignoring exit from {} (already in {})'.format(
location_name, current_state))
elif direction == 'test':
# In the app, a test message can be sent. Just return something to
# the user to let them know that it works.
handler.write_text("Received test message.")
else:
handler.write_text(
"Received unidentified message: {}".format(direction),
HTTP_UNPROCESSABLE_ENTITY)
_LOGGER.error("Received unidentified message from Locative: %s",
direction)
def _check_data(handler, data):
"""Check the data."""
if 'latitude' not in data or 'longitude' not in data:
handler.write_text("Latitude and longitude not specified.",
HTTP_UNPROCESSABLE_ENTITY)
_LOGGER.error("Latitude and longitude not specified.")
return False
if 'device' not in data:
handler.write_text("Device id not specified.",
HTTP_UNPROCESSABLE_ENTITY)
_LOGGER.error("Device id not specified.")
return False
if 'id' not in data:
handler.write_text("Location id not specified.",
HTTP_UNPROCESSABLE_ENTITY)
_LOGGER.error("Location id not specified.")
return False
if 'trigger' not in data:
handler.write_text("Trigger is not specified.",
HTTP_UNPROCESSABLE_ENTITY)
_LOGGER.error("Trigger is not specified.")
return False
return True
_LOGGER.error("Received unidentified message from Locative: %s",
direction)
return ("Received unidentified message: {}".format(direction),
HTTP_UNPROCESSABLE_ENTITY)

147
homeassistant/components/frontend/__init__.py
View file

@ -4,9 +4,9 @@ import os
import logging
from . import version, mdi_version
import homeassistant.util as util
from homeassistant.const import URL_ROOT, HTTP_OK
from homeassistant.const import URL_ROOT
from homeassistant.components import api
from homeassistant.components.http import HomeAssistantView
DOMAIN = 'frontend'
DEPENDENCIES = ['api']
@ -28,94 +28,81 @@ _FINGERPRINT = re.compile(r'^(\w+)-[a-z0-9]{32}\.(\w+)$', re.IGNORECASE)
def setup(hass, config):
"""Setup serving the frontend."""
for url in FRONTEND_URLS:
hass.http.register_path('GET', url, _handle_get_root, False)
hass.wsgi.register_view(IndexView)
hass.wsgi.register_view(BootstrapView)
hass.http.register_path('GET', '/service_worker.js',
_handle_get_service_worker, False)
# Bootstrap API
hass.http.register_path(
'GET', URL_API_BOOTSTRAP, _handle_get_api_bootstrap)
# Static files
hass.http.register_path(
'GET', re.compile(r'/static/(?P<file>[a-zA-Z\._\-0-9/]+)'),
_handle_get_static, False)
hass.http.register_path(
'HEAD', re.compile(r'/static/(?P<file>[a-zA-Z\._\-0-9/]+)'),
_handle_get_static, False)
hass.http.register_path(
'GET', re.compile(r'/local/(?P<file>[a-zA-Z\._\-0-9/]+)'),
_handle_get_local, False)
return True
def _handle_get_api_bootstrap(handler, path_match, data):
"""Return all data needed to bootstrap Home Assistant."""
hass = handler.server.hass
handler.write_json({
'config': hass.config.as_dict(),
'states': hass.states.all(),
'events': api.events_json(hass),
'services': api.services_json(hass),
})
def _handle_get_root(handler, path_match, data):
"""Render the frontend."""
if handler.server.development:
app_url = "home-assistant-polymer/src/home-assistant.html"
else:
app_url = "frontend-{}.html".format(version.VERSION)
# auto login if no password was set, else check api_password param
auth = ('no_password_set' if handler.server.api_password is None
else data.get('api_password', ''))
with open(INDEX_PATH) as template_file:
template_html = template_file.read()
template_html = template_html.replace('{{ app_url }}', app_url)
template_html = template_html.replace('{{ auth }}', auth)
template_html = template_html.replace('{{ icons }}', mdi_version.VERSION)
handler.send_response(HTTP_OK)
handler.write_content(template_html.encode("UTF-8"),
'text/html; charset=utf-8')
def _handle_get_service_worker(handler, path_match, data):
"""Return service worker for the frontend."""
if handler.server.development:
www_static_path = os.path.join(os.path.dirname(__file__), 'www_static')
if hass.wsgi.development:
sw_path = "home-assistant-polymer/build/service_worker.js"
else:
sw_path = "service_worker.js"
handler.write_file(os.path.join(os.path.dirname(__file__), 'www_static',
sw_path))
hass.wsgi.register_static_path(
"/service_worker.js",
os.path.join(www_static_path, sw_path)
)
hass.wsgi.register_static_path("/static", www_static_path)
hass.wsgi.register_static_path("/local", hass.config.path('www'))
return True
def _handle_get_static(handler, path_match, data):
"""Return a static file for the frontend."""
req_file = util.sanitize_path(path_match.group('file'))
class BootstrapView(HomeAssistantView):
"""View to bootstrap frontend with all needed data."""
# Strip md5 hash out
fingerprinted = _FINGERPRINT.match(req_file)
if fingerprinted:
req_file = "{}.{}".format(*fingerprinted.groups())
url = URL_API_BOOTSTRAP
name = "api:bootstrap"
path = os.path.join(os.path.dirname(__file__), 'www_static', req_file)
handler.write_file(path)
def get(self, request):
"""Return all data needed to bootstrap Home Assistant."""
return self.json({
'config': self.hass.config.as_dict(),
'states': self.hass.states.all(),
'events': api.events_json(self.hass),
'services': api.services_json(self.hass),
})
def _handle_get_local(handler, path_match, data):
"""Return a static file from the hass.config.path/www for the frontend."""
req_file = util.sanitize_path(path_match.group('file'))
class IndexView(HomeAssistantView):
"""Serve the frontend."""
path = handler.server.hass.config.path('www', req_file)
url = URL_ROOT
name = "frontend:index"
requires_auth = False
extra_urls = ['/logbook', '/history', '/map', '/devService', '/devState',
'/devEvent', '/devInfo', '/devTemplate',
'/states', '/states/<entity:entity_id>']
handler.write_file(path)
def __init__(self, hass):
"""Initialize the frontend view."""
super().__init__(hass)
from jinja2 import FileSystemLoader, Environment
self.templates = Environment(
loader=FileSystemLoader(
os.path.join(os.path.dirname(__file__), 'templates/')
)
)
def get(self, request, entity_id=None):
"""Serve the index view."""
if self.hass.wsgi.development:
app_url = 'home-assistant-polymer/src/home-assistant.html'
else:
app_url = "frontend-{}.html".format(version.VERSION)
# auto login if no password was set, else check api_password param
if self.hass.config.api.api_password is None:
auth = 'no_password_set'
else:
auth = request.values.get('api_password', '')
template = self.templates.get_template('index.html')
# pylint is wrong
# pylint: disable=no-member
resp = template.render(app_url=app_url, auth=auth,
icons=mdi_version.VERSION)
return self.Response(resp, mimetype="text/html")

2
homeassistant/components/frontend/mdi_version.py
View file

@ -1,2 +1,2 @@
"""DO NOT MODIFY. Auto-generated by update_mdi script."""
VERSION = "1baebe8155deb447230866d7ae854bd9"
VERSION = "9ee3d4466a65bef35c2c8974e91b37c0"

51
homeassistant/components/frontend/templates/index.html Normal file
View file

@ -0,0 +1,51 @@
<!doctype html>
<html lang="en">
<head>
<meta charset="utf-8">
<title>Home Assistant</title>
<link rel='manifest' href='/static/manifest.json'>
<link rel='icon' href='/static/favicon.ico'>
<link rel='apple-touch-icon' sizes='180x180'
href='/static/favicon-apple-180x180.png'>
<meta name='apple-mobile-web-app-capable' content='yes'>
<meta name='mobile-web-app-capable' content='yes'>
<meta name='viewport' content='width=device-width, user-scalable=no'>
<meta name='theme-color' content='#03a9f4'>
<style>
#ha-init-skeleton {
display: -webkit-flex;
display: flex;
-webkit-flex-direction: column;
-webkit-justify-content: center;
-webkit-align-items: center;
flex-direction: column;
justify-content: center;
align-items: center;
text-align: center;
position: fixed;
top: 0;
left: 0;
right: 0;
bottom: 0;
margin-bottom: 123px;
}
</style>
<link rel='import' href='/static/{{ app_url }}' async>
</head>
<body fullbleed>
<div id='ha-init-skeleton'><img src='/static/favicon-192x192.png' height='192'></div>
<script>
var webComponentsSupported = ('registerElement' in document &&
'import' in document.createElement('link') &&
'content' in document.createElement('template'))
if (!webComponentsSupported) {
var script = document.createElement('script')
script.async = true
script.src = '/static/webcomponents-lite.min.js'
document.head.appendChild(script)
}
</script>
<home-assistant auth='{{ auth }}' icons='{{ icons }}'></home-assistant>
</body>
</html>

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Black.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-BlackItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Bold.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-BoldItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Italic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Light.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-LightItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Medium.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-MediumItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Regular.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-Thin.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/roboto/Roboto-ThinItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-Bold.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-BoldItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-Italic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-Light.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-LightItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-Medium.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-MediumItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-Regular.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-Thin.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/fonts/robotomono/RobotoMono-ThinItalic.ttf.gz Normal file
View file

Binary file not shown.

BIN
homeassistant/components/frontend/www_static/frontend.html.gz Normal file
View file

Binary file not shown.

2
homeassistant/components/frontend/www_static/mdi.html
View file

File diff suppressed because one or more lines are too long

BIN
homeassistant/components/frontend/www_static/mdi.html.gz Normal file
View file

Binary file not shown.

63
homeassistant/components/history.py
View file

@ -12,6 +12,7 @@ from itertools import groupby
from homeassistant.components import recorder, script
import homeassistant.util.dt as dt_util
from homeassistant.const import HTTP_BAD_REQUEST
from homeassistant.components.http import HomeAssistantView
DOMAIN = 'history'
DEPENDENCIES = ['recorder', 'http']
@ -155,49 +156,51 @@ def get_state(utc_point_in_time, entity_id, run=None):
# pylint: disable=unused-argument
def setup(hass, config):
"""Setup the history hooks."""
hass.http.register_path(
'GET',
re.compile(
r'/api/history/entity/(?P<entity_id>[a-zA-Z\._0-9]+)/'
r'recent_states'),
_api_last_5_states)
hass.http.register_path('GET', URL_HISTORY_PERIOD, _api_history_period)
hass.wsgi.register_view(Last5StatesView)
hass.wsgi.register_view(HistoryPeriodView)
return True
# pylint: disable=unused-argument
# pylint: disable=invalid-name
def _api_last_5_states(handler, path_match, data):
"""Return the last 5 states for an entity id as JSON."""
entity_id = path_match.group('entity_id')
class Last5StatesView(HomeAssistantView):
"""Handle last 5 state view requests."""
handler.write_json(last_5_states(entity_id))
url = '/api/history/entity/<entity:entity_id>/recent_states'
name = 'api:history:entity-recent-states'
def get(self, request, entity_id):
"""Retrieve last 5 states of entity."""
return self.json(last_5_states(entity_id))
def _api_history_period(handler, path_match, data):
"""Return history over a period of time."""
date_str = path_match.group('date')
one_day = timedelta(seconds=86400)
class HistoryPeriodView(HomeAssistantView):
"""Handle history period requests."""
if date_str:
start_date = dt_util.parse_date(date_str)
url = '/api/history/period'
name = 'api:history:entity-recent-states'
extra_urls = ['/api/history/period/<date:date>']
if start_date is None:
handler.write_json_message("Error parsing JSON", HTTP_BAD_REQUEST)
return
def get(self, request, date=None):
"""Return history over a period of time."""
one_day = timedelta(seconds=86400)
start_time = dt_util.as_utc(dt_util.start_of_local_day(start_date))
else:
start_time = dt_util.utcnow() - one_day
if date:
start_date = dt_util.parse_date(date)
end_time = start_time + one_day
if start_date is None:
return self.json_message('Error parsing JSON',
HTTP_BAD_REQUEST)
entity_id = data.get('filter_entity_id')
start_time = dt_util.as_utc(dt_util.start_of_local_day(start_date))
else:
start_time = dt_util.utcnow() - one_day
handler.write_json(
get_significant_states(start_time, end_time, entity_id).values())
end_time = start_time + one_day
entity_id = request.args.get('filter_entity_id')
return self.json(
get_significant_states(start_time, end_time, entity_id).values())
def _is_significant(state):

730
homeassistant/components/http.py
View file

@ -1,41 +1,21 @@
"""
This module provides an API and a HTTP interface for debug purposes.
For more details about the RESTful API, please refer to the documentation at
https://home-assistant.io/developers/api/
"""
import gzip
"""This module provides WSGI application to serve the Home Assistant API."""
import hmac
import json
import logging
import ssl
import mimetypes
import threading
import time
from datetime import timedelta
from http import cookies
from http.server import HTTPServer, SimpleHTTPRequestHandler
from socketserver import ThreadingMixIn
from urllib.parse import parse_qs, urlparse
import voluptuous as vol
import re
import homeassistant.bootstrap as bootstrap
import homeassistant.core as ha
import homeassistant.remote as rem
import homeassistant.util as util
import homeassistant.util.dt as date_util
import homeassistant.helpers.config_validation as cv
from homeassistant import util
from homeassistant.const import (
CONTENT_TYPE_JSON, CONTENT_TYPE_TEXT_PLAIN, HTTP_HEADER_ACCEPT_ENCODING,
HTTP_HEADER_CACHE_CONTROL, HTTP_HEADER_CONTENT_ENCODING,
HTTP_HEADER_CONTENT_LENGTH, HTTP_HEADER_CONTENT_TYPE, HTTP_HEADER_EXPIRES,
HTTP_HEADER_HA_AUTH, HTTP_HEADER_VARY,
HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
HTTP_HEADER_ACCESS_CONTROL_ALLOW_HEADERS, HTTP_METHOD_NOT_ALLOWED,
HTTP_NOT_FOUND, HTTP_OK, HTTP_UNAUTHORIZED, HTTP_UNPROCESSABLE_ENTITY,
ALLOWED_CORS_HEADERS,
SERVER_PORT, URL_ROOT, URL_API_EVENT_FORWARD)
SERVER_PORT, HTTP_HEADER_HA_AUTH, HTTP_HEADER_CACHE_CONTROL)
from homeassistant.helpers.entity import split_entity_id
import homeassistant.util.dt as dt_util
DOMAIN = "http"
REQUIREMENTS = ("eventlet==0.18.4", "static3==0.7.0", "Werkzeug==0.11.5",)
CONF_API_PASSWORD = "api_password"
CONF_SERVER_HOST = "server_host"
@ -43,61 +23,42 @@ CONF_SERVER_PORT = "server_port"
CONF_DEVELOPMENT = "development"
CONF_SSL_CERTIFICATE = 'ssl_certificate'
CONF_SSL_KEY = 'ssl_key'
CONF_CORS_ORIGINS = 'cors_allowed_origins'
DATA_API_PASSWORD = 'api_password'
# Throttling time in seconds for expired sessions check
SESSION_CLEAR_INTERVAL = timedelta(seconds=20)
SESSION_TIMEOUT_SECONDS = 1800
SESSION_KEY = 'sessionId'
_FINGERPRINT = re.compile(r'^(.+)-[a-z0-9]{32}\.(\w+)$', re.IGNORECASE)
_LOGGER = logging.getLogger(__name__)
CONFIG_SCHEMA = vol.Schema({
DOMAIN: vol.Schema({
vol.Optional(CONF_API_PASSWORD): cv.string,
vol.Optional(CONF_SERVER_HOST): cv.string,
vol.Optional(CONF_SERVER_PORT, default=SERVER_PORT):
vol.All(vol.Coerce(int), vol.Range(min=1, max=65535)),
vol.Optional(CONF_DEVELOPMENT): cv.string,
vol.Optional(CONF_SSL_CERTIFICATE): cv.isfile,
vol.Optional(CONF_SSL_KEY): cv.isfile,
vol.Optional(CONF_CORS_ORIGINS): cv.ensure_list
}),
}, extra=vol.ALLOW_EXTRA)
def setup(hass, config):
"""Set up the HTTP API and debug interface."""
conf = config.get(DOMAIN, {})
api_password = util.convert(conf.get(CONF_API_PASSWORD), str)
# If no server host is given, accept all incoming requests
server_host = conf.get(CONF_SERVER_HOST, '0.0.0.0')
server_port = conf.get(CONF_SERVER_PORT, SERVER_PORT)
development = str(conf.get(CONF_DEVELOPMENT, "")) == "1"
ssl_certificate = conf.get(CONF_SSL_CERTIFICATE)
ssl_key = conf.get(CONF_SSL_KEY)
cors_origins = conf.get(CONF_CORS_ORIGINS, [])
try:
server = HomeAssistantHTTPServer(
(server_host, server_port), RequestHandler, hass, api_password,
development, ssl_certificate, ssl_key, cors_origins)
except OSError:
# If address already in use
_LOGGER.exception("Error setting up HTTP server")
return False
server = HomeAssistantWSGI(
hass,
development=development,
server_host=server_host,
server_port=server_port,
api_password=api_password,
ssl_certificate=ssl_certificate,
ssl_key=ssl_key,
)
hass.bus.listen_once(
ha.EVENT_HOMEASSISTANT_START,
lambda event:
threading.Thread(target=server.start, daemon=True,
name='HTTP-server').start())
name='WSGI-server').start())
hass.http = server
hass.wsgi = server
hass.config.api = rem.API(server_host if server_host != '0.0.0.0'
else util.get_local_ip(),
api_password, server_port,
@ -106,413 +67,338 @@ def setup(hass, config):
return True
# pylint: disable=too-many-instance-attributes
class HomeAssistantHTTPServer(ThreadingMixIn, HTTPServer):
"""Handle HTTP requests in a threaded fashion."""
def request_class():
"""Generate request class.
# pylint: disable=too-few-public-methods
allow_reuse_address = True
daemon_threads = True
Done in method because of imports.
"""
from werkzeug.exceptions import BadRequest
from werkzeug.wrappers import BaseRequest, AcceptMixin
from werkzeug.utils import cached_property
class Request(BaseRequest, AcceptMixin):
"""Base class for incoming requests."""
@cached_property
def json(self):
"""Get the result of json.loads if possible."""
if not self.data:
return None
# elif 'json' not in self.environ.get('CONTENT_TYPE', ''):
# raise BadRequest('Not a JSON request')
try:
return json.loads(self.data.decode(
self.charset, self.encoding_errors))
except (TypeError, ValueError):
raise BadRequest('Unable to read JSON request')
return Request
def routing_map(hass):
"""Generate empty routing map with HA validators."""
from werkzeug.routing import Map, BaseConverter, ValidationError
class EntityValidator(BaseConverter):
"""Validate entity_id in urls."""
regex = r"(\w+)\.(\w+)"
def __init__(self, url_map, exist=True, domain=None):
"""Initilalize entity validator."""
super().__init__(url_map)
self._exist = exist
self._domain = domain
def to_python(self, value):
"""Validate entity id."""
if self._exist and hass.states.get(value) is None:
raise ValidationError()
if self._domain is not None and \
split_entity_id(value)[0] != self._domain:
raise ValidationError()
return value
def to_url(self, value):
"""Convert entity_id for a url."""
return value
class DateValidator(BaseConverter):
"""Validate dates in urls."""
regex = r'\d{4}-(0[1-9])|(1[012])-((0[1-9])|([12]\d)|(3[01]))'
def to_python(self, value):
"""Validate and convert date."""
parsed = dt_util.parse_date(value)
if value is None:
raise ValidationError()
return parsed
def to_url(self, value):
"""Convert date to url value."""
return value.isoformat()
return Map(converters={
'entity': EntityValidator,
'date': DateValidator,
})
class HomeAssistantWSGI(object):
"""WSGI server for Home Assistant."""
# pylint: disable=too-many-instance-attributes, too-many-locals
# pylint: disable=too-many-arguments
def __init__(self, server_address, request_handler_class,
hass, api_password, development, ssl_certificate, ssl_key,
cors_origins):
"""Initialize the server."""
super().__init__(server_address, request_handler_class)
self.server_address = server_address
def __init__(self, hass, development, api_password, ssl_certificate,
ssl_key, server_host, server_port):
"""Initilalize the WSGI Home Assistant server."""
from werkzeug.wrappers import Response
Response.mimetype = 'text/html'
# pylint: disable=invalid-name
self.Request = request_class()
self.url_map = routing_map(hass)
self.views = {}
self.hass = hass
self.api_password = api_password
self.extra_apps = {}
self.development = development
self.paths = []
self.sessions = SessionStore()
self.use_ssl = ssl_certificate is not None
self.cors_origins = cors_origins
# We will lazy init this one if needed
self.api_password = api_password
self.ssl_certificate = ssl_certificate
self.ssl_key = ssl_key
self.server_host = server_host
self.server_port = server_port
self.event_forwarder = None
if development:
_LOGGER.info("running http in development mode")
def register_view(self, view):
"""Register a view with the WSGI server.
if ssl_certificate is not None:
context = ssl.create_default_context(
purpose=ssl.Purpose.CLIENT_AUTH)
context.load_cert_chain(ssl_certificate, keyfile=ssl_key)
self.socket = context.wrap_socket(self.socket, server_side=True)
The view argument must be a class that inherits from HomeAssistantView.
It is optional to instantiate it before registering; this method will
handle it either way.
"""
from werkzeug.routing import Rule
if view.name in self.views:
_LOGGER.warning("View '%s' is being overwritten", view.name)
if isinstance(view, type):
# Instantiate the view, if needed
view = view(self.hass)
self.views[view.name] = view
rule = Rule(view.url, endpoint=view.name)
self.url_map.add(rule)
for url in view.extra_urls:
rule = Rule(url, endpoint=view.name)
self.url_map.add(rule)
def register_redirect(self, url, redirect_to):
"""Register a redirect with the server.
If given this must be either a string or callable. In case of a
callable it’s called with the url adapter that triggered the match and
the values of the URL as keyword arguments and has to return the target
for the redirect, otherwise it has to be a string with placeholders in
rule syntax.
"""
from werkzeug.routing import Rule
self.url_map.add(Rule(url, redirect_to=redirect_to))
def register_static_path(self, url_root, path):
"""Register a folder to serve as a static path."""
from static import Cling
headers = []
if not self.development:
# 1 year in seconds
cache_time = 365 * 86400
headers.append({
'prefix': '',
HTTP_HEADER_CACHE_CONTROL:
"public, max-age={}".format(cache_time)
})
self.register_wsgi_app(url_root, Cling(path, headers=headers))
def register_wsgi_app(self, url_root, app):
"""Register a path to serve a WSGI app."""
if url_root in self.extra_apps:
_LOGGER.warning("Url root '%s' is being overwritten", url_root)
self.extra_apps[url_root] = app
def start(self):
"""Start the HTTP server."""
def stop_http(event):
"""Stop the HTTP server."""
self.shutdown()
"""Start the wsgi server."""
from eventlet import wsgi
import eventlet
self.hass.bus.listen_once(ha.EVENT_HOMEASSISTANT_STOP, stop_http)
sock = eventlet.listen((self.server_host, self.server_port))
if self.ssl_certificate:
eventlet.wrap_ssl(sock, certfile=self.ssl_certificate,
keyfile=self.ssl_key, server_side=True)
wsgi.server(sock, self)
protocol = 'https' if self.use_ssl else 'http'
_LOGGER.info(
"Starting web interface at %s://%s:%d",
protocol, self.server_address[0], self.server_address[1])
# 31-1-2015: Refactored frontend/api components out of this component
# To prevent stuff from breaking, load the two extracted components
bootstrap.setup_component(self.hass, 'api')
bootstrap.setup_component(self.hass, 'frontend')
self.serve_forever()
def register_path(self, method, url, callback, require_auth=True):
"""Register a path with the server."""
self.paths.append((method, url, callback, require_auth))
def log_message(self, fmt, *args):
"""Redirect built-in log to HA logging."""
# pylint: disable=no-self-use
_LOGGER.info(fmt, *args)
# pylint: disable=too-many-public-methods,too-many-locals
class RequestHandler(SimpleHTTPRequestHandler):
"""Handle incoming HTTP requests.
We extend from SimpleHTTPRequestHandler instead of Base so we
can use the guess content type methods.
"""
server_version = "HomeAssistant/1.0"
def __init__(self, req, client_addr, server):
"""Constructor, call the base constructor and set up session."""
# Track if this was an authenticated request
self.authenticated = False
SimpleHTTPRequestHandler.__init__(self, req, client_addr, server)
self.protocol_version = 'HTTP/1.1'
def log_message(self, fmt, *arguments):
"""Redirect built-in log to HA logging."""
if self.server.api_password is None:
_LOGGER.info(fmt, *arguments)
else:
_LOGGER.info(
fmt, *(arg.replace(self.server.api_password, '*******')
if isinstance(arg, str) else arg for arg in arguments))
def _handle_request(self, method): # pylint: disable=too-many-branches
"""Perform some common checks and call appropriate method."""
url = urlparse(self.path)
# Read query input. parse_qs gives a list for each value, we want last
data = {key: data[-1] for key, data in parse_qs(url.query).items()}
# Did we get post input ?
content_length = int(self.headers.get(HTTP_HEADER_CONTENT_LENGTH, 0))
if content_length:
body_content = self.rfile.read(content_length).decode("UTF-8")
def dispatch_request(self, request):
"""Handle incoming request."""
from werkzeug.exceptions import (
MethodNotAllowed, NotFound, BadRequest, Unauthorized,
)
from werkzeug.routing import RequestRedirect
with request:
adapter = self.url_map.bind_to_environ(request.environ)
try:
data.update(json.loads(body_content))
except (TypeError, ValueError):
# TypeError if JSON object is not a dict
# ValueError if we could not parse JSON
_LOGGER.exception(
"Exception parsing JSON: %s", body_content)
self.write_json_message(
"Error parsing JSON", HTTP_UNPROCESSABLE_ENTITY)
return
endpoint, values = adapter.match()
return self.views[endpoint].handle_request(request, **values)
except RequestRedirect as ex:
return ex
except (BadRequest, NotFound, MethodNotAllowed,
Unauthorized) as ex:
resp = ex.get_response(request.environ)
if request.accept_mimetypes.accept_json:
resp.data = json.dumps({
"result": "error",
"message": str(ex),
})
resp.mimetype = "application/json"
return resp
if self.verify_session():
# The user has a valid session already
self.authenticated = True
elif self.server.api_password is None:
# No password is set, so everyone is authenticated
self.authenticated = True
elif hmac.compare_digest(self.headers.get(HTTP_HEADER_HA_AUTH, ''),
self.server.api_password):
# A valid auth header has been set
self.authenticated = True
elif hmac.compare_digest(data.get(DATA_API_PASSWORD, ''),
self.server.api_password):
# A valid password has been specified
self.authenticated = True
else:
self.authenticated = False
def base_app(self, environ, start_response):
"""WSGI Handler of requests to base app."""
request = self.Request(environ)
response = self.dispatch_request(request)
return response(environ, start_response)
# we really shouldn't need to forward the password from here
if url.path not in [URL_ROOT, URL_API_EVENT_FORWARD]:
data.pop(DATA_API_PASSWORD, None)
def __call__(self, environ, start_response):
"""Handle a request for base app + extra apps."""
from werkzeug.wsgi import DispatcherMiddleware
if '_METHOD' in data:
method = data.pop('_METHOD')
app = DispatcherMiddleware(self.base_app, self.extra_apps)
# Strip out any cachebusting MD5 fingerprints
fingerprinted = _FINGERPRINT.match(environ.get('PATH_INFO', ''))
if fingerprinted:
environ['PATH_INFO'] = "{}.{}".format(*fingerprinted.groups())
return app(environ, start_response)
# Var to keep track if we found a path that matched a handler but
# the method was different
path_matched_but_not_method = False
# Var to hold the handler for this path and method if found
handle_request_method = False
require_auth = True
class HomeAssistantView(object):
"""Base view for all views."""
# Check every handler to find matching result
for t_method, t_path, t_handler, t_auth in self.server.paths:
# we either do string-comparison or regular expression matching
# pylint: disable=maybe-no-member
if isinstance(t_path, str):
path_match = url.path == t_path
else:
path_match = t_path.match(url.path)
extra_urls = []
requires_auth = True # Views inheriting from this class can override this
if path_match and method == t_method:
# Call the method
handle_request_method = t_handler
require_auth = t_auth
break
def __init__(self, hass):
"""Initilalize the base view."""
from werkzeug.wrappers import Response
elif path_match:
path_matched_but_not_method = True
if not hasattr(self, 'url'):
class_name = self.__class__.__name__
raise AttributeError(
'{0} missing required attribute "url"'.format(class_name)
)
# Did we find a handler for the incoming request?
if handle_request_method:
# For some calls we need a valid password
msg = "API password missing or incorrect."
if require_auth and not self.authenticated:
self.write_json_message(msg, HTTP_UNAUTHORIZED)
_LOGGER.warning('%s Source IP: %s',
msg,
self.client_address[0])
return
if not hasattr(self, 'name'):
class_name = self.__class__.__name__
raise AttributeError(
'{0} missing required attribute "name"'.format(class_name)
)
handle_request_method(self, path_match, data)
self.hass = hass
# pylint: disable=invalid-name
self.Response = Response
elif path_matched_but_not_method:
self.send_response(HTTP_METHOD_NOT_ALLOWED)
self.end_headers()
else:
self.send_response(HTTP_NOT_FOUND)
self.end_headers()
def do_HEAD(self): # pylint: disable=invalid-name
"""HEAD request handler."""
self._handle_request('HEAD')
def do_GET(self): # pylint: disable=invalid-name
"""GET request handler."""
self._handle_request('GET')
def do_POST(self): # pylint: disable=invalid-name
"""POST request handler."""
self._handle_request('POST')
def do_PUT(self): # pylint: disable=invalid-name
"""PUT request handler."""
self._handle_request('PUT')
def do_DELETE(self): # pylint: disable=invalid-name
"""DELETE request handler."""
self._handle_request('DELETE')
def write_json_message(self, message, status_code=HTTP_OK):
"""Helper method to return a message to the caller."""
self.write_json({'message': message}, status_code=status_code)
def write_json(self, data=None, status_code=HTTP_OK, location=None):
"""Helper method to return JSON to the caller."""
json_data = json.dumps(data, indent=4, sort_keys=True,
cls=rem.JSONEncoder).encode('UTF-8')
self.send_response(status_code)
if location:
self.send_header('Location', location)
self.set_session_cookie_header()
self.write_content(json_data, CONTENT_TYPE_JSON)
def write_text(self, message, status_code=HTTP_OK):
"""Helper method to return a text message to the caller."""
msg_data = message.encode('UTF-8')
self.send_response(status_code)
self.set_session_cookie_header()
self.write_content(msg_data, CONTENT_TYPE_TEXT_PLAIN)
def write_file(self, path, cache_headers=True):
"""Return a file to the user."""
try:
with open(path, 'rb') as inp:
self.write_file_pointer(self.guess_type(path), inp,
cache_headers)
except IOError:
self.send_response(HTTP_NOT_FOUND)
self.end_headers()
_LOGGER.exception("Unable to serve %s", path)
def write_file_pointer(self, content_type, inp, cache_headers=True):
"""Helper function to write a file pointer to the user."""
self.send_response(HTTP_OK)
if cache_headers:
self.set_cache_header()
self.set_session_cookie_header()
self.write_content(inp.read(), content_type)
def write_content(self, content, content_type=None):
"""Helper method to write content bytes to output stream."""
if content_type is not None:
self.send_header(HTTP_HEADER_CONTENT_TYPE, content_type)
if 'gzip' in self.headers.get(HTTP_HEADER_ACCEPT_ENCODING, ''):
content = gzip.compress(content)
self.send_header(HTTP_HEADER_CONTENT_ENCODING, "gzip")
self.send_header(HTTP_HEADER_VARY, HTTP_HEADER_ACCEPT_ENCODING)
self.send_header(HTTP_HEADER_CONTENT_LENGTH, str(len(content)))
cors_check = (self.headers.get("Origin") in self.server.cors_origins)
cors_headers = ", ".join(ALLOWED_CORS_HEADERS)
if self.server.cors_origins and cors_check:
self.send_header(HTTP_HEADER_ACCESS_CONTROL_ALLOW_ORIGIN,
self.headers.get("Origin"))
self.send_header(HTTP_HEADER_ACCESS_CONTROL_ALLOW_HEADERS,
cors_headers)
self.end_headers()
if self.command == 'HEAD':
return
self.wfile.write(content)
def set_cache_header(self):
"""Add cache headers if not in development."""
if self.server.development:
return
# 1 year in seconds
cache_time = 365 * 86400
self.send_header(
HTTP_HEADER_CACHE_CONTROL,
"public, max-age={}".format(cache_time))
self.send_header(
HTTP_HEADER_EXPIRES,
self.date_time_string(time.time()+cache_time))
def set_session_cookie_header(self):
"""Add the header for the session cookie and return session ID."""
if not self.authenticated:
return None
session_id = self.get_cookie_session_id()
if session_id is not None:
self.server.sessions.extend_validation(session_id)
return session_id
self.send_header(
'Set-Cookie',
'{}={}'.format(SESSION_KEY, self.server.sessions.create())
def handle_request(self, request, **values):
"""Handle request to url."""
from werkzeug.exceptions import (
MethodNotAllowed, Unauthorized, BadRequest,
)
return session_id
def verify_session(self):
"""Verify that we are in a valid session."""
return self.get_cookie_session_id() is not None
def get_cookie_session_id(self):
"""Extract the current session ID from the cookie.
Return None if not set or invalid.
"""
if 'Cookie' not in self.headers:
return None
cookie = cookies.SimpleCookie()
try:
cookie.load(self.headers["Cookie"])
except cookies.CookieError:
return None
handler = getattr(self, request.method.lower())
except AttributeError:
raise MethodNotAllowed
morsel = cookie.get(SESSION_KEY)
# Auth code verbose on purpose
authenticated = False
if morsel is None:
return None
if self.hass.wsgi.api_password is None:
authenticated = True
session_id = cookie[SESSION_KEY].value
elif hmac.compare_digest(request.headers.get(HTTP_HEADER_HA_AUTH, ''),
self.hass.wsgi.api_password):
# A valid auth header has been set
authenticated = True
if self.server.sessions.is_valid(session_id):
return session_id
elif hmac.compare_digest(request.args.get(DATA_API_PASSWORD, ''),
self.hass.wsgi.api_password):
authenticated = True
return None
else:
# Do we still want to support passing it in as post data?
try:
json_data = request.json
if (json_data is not None and
hmac.compare_digest(
json_data.get(DATA_API_PASSWORD, ''),
self.hass.wsgi.api_password)):
authenticated = True
except BadRequest:
pass
def destroy_session(self):
"""Destroy the session."""
session_id = self.get_cookie_session_id()
if self.requires_auth and not authenticated:
raise Unauthorized()
if session_id is None:
return
request.authenticated = authenticated
self.send_header('Set-Cookie', '')
self.server.sessions.destroy(session_id)
result = handler(request, **values)
if isinstance(result, self.Response):
# The method handler returned a ready-made Response, how nice of it
return result
def session_valid_time():
"""Time till when a session will be valid."""
return date_util.utcnow() + timedelta(seconds=SESSION_TIMEOUT_SECONDS)
status_code = 200
if isinstance(result, tuple):
result, status_code = result
class SessionStore(object):
"""Responsible for storing and retrieving HTTP sessions."""
return self.Response(result, status=status_code)
def __init__(self):
"""Setup the session store."""
self._sessions = {}
self._lock = threading.RLock()
def json(self, result, status_code=200):
"""Return a JSON response."""
msg = json.dumps(
result,
sort_keys=True,
cls=rem.JSONEncoder
).encode('UTF-8')
return self.Response(msg, mimetype="application/json",
status=status_code)
@util.Throttle(SESSION_CLEAR_INTERVAL)
def _remove_expired(self):
"""Remove any expired sessions."""
now = date_util.utcnow()
for key in [key for key, valid_time in self._sessions.items()
if valid_time < now]:
self._sessions.pop(key)
def json_message(self, error, status_code=200):
"""Return a JSON message response."""
return self.json({'message': error}, status_code)
def is_valid(self, key):
"""Return True if a valid session is given."""
with self._lock:
self._remove_expired()
def file(self, request, fil, mimetype=None):
"""Return a file."""
from werkzeug.wsgi import wrap_file
from werkzeug.exceptions import NotFound
return (key in self._sessions and
self._sessions[key] > date_util.utcnow())
if isinstance(fil, str):
if mimetype is None:
mimetype = mimetypes.guess_type(fil)[0]
def extend_validation(self, key):
"""Extend a session validation time."""
with self._lock:
if key not in self._sessions:
return
self._sessions[key] = session_valid_time()
try:
fil = open(fil)
except IOError:
raise NotFound()
def destroy(self, key):
"""Destroy a session by key."""
with self._lock:
self._sessions.pop(key, None)
def create(self):
"""Create a new session."""
with self._lock:
session_id = util.get_random_string(20)
while session_id in self._sessions:
session_id = util.get_random_string(20)
self._sessions[session_id] = session_valid_time()
return session_id
return self.Response(wrap_file(request.environ, fil),
mimetype=mimetype, direct_passthrough=True)

41
homeassistant/components/logbook.py
View file

@ -21,6 +21,7 @@ from homeassistant.core import State
from homeassistant.helpers.entity import split_entity_id
from homeassistant.helpers import template
import homeassistant.helpers.config_validation as cv
from homeassistant.components.http import HomeAssistantView
DOMAIN = "logbook"
DEPENDENCIES = ['recorder', 'http']
@ -76,34 +77,40 @@ def setup(hass, config):
message = template.render(hass, message)
log_entry(hass, name, message, domain, entity_id)
hass.http.register_path('GET', URL_LOGBOOK, _handle_get_logbook)
hass.wsgi.register_view(LogbookView)
hass.services.register(DOMAIN, 'log', log_message,
schema=LOG_MESSAGE_SCHEMA)
return True
def _handle_get_logbook(handler, path_match, data):
"""Return logbook entries."""
date_str = path_match.group('date')
class LogbookView(HomeAssistantView):
"""Handle logbook view requests."""
if date_str:
start_date = dt_util.parse_date(date_str)
url = '/api/logbook'
name = 'api:logbook'
extra_urls = ['/api/logbook/<date:date>']
if start_date is None:
handler.write_json_message("Error parsing JSON", HTTP_BAD_REQUEST)
return
def get(self, request, date=None):
"""Retrieve logbook entries."""
if date:
start_date = dt_util.parse_date(date)
start_day = dt_util.start_of_local_day(start_date)
else:
start_day = dt_util.start_of_local_day()
if start_date is None:
return self.json_message('Error parsing JSON',
HTTP_BAD_REQUEST)
end_day = start_day + timedelta(days=1)
start_day = dt_util.start_of_local_day(start_date)
else:
start_day = dt_util.start_of_local_day()
events = recorder.query_events(
QUERY_EVENTS_BETWEEN,
(dt_util.as_utc(start_day), dt_util.as_utc(end_day)))
end_day = start_day + timedelta(days=1)
handler.write_json(humanify(events))
events = recorder.query_events(
QUERY_EVENTS_BETWEEN,
(dt_util.as_utc(start_day), dt_util.as_utc(end_day)))
return self.json(humanify(events))
class Entry(object):

134
homeassistant/components/sensor/fitbit.py
View file

@ -10,10 +10,11 @@ import logging
import datetime
import time
from homeassistant.const import HTTP_OK, TEMP_CELSIUS
from homeassistant.const import TEMP_CELSIUS
from homeassistant.util import Throttle
from homeassistant.helpers.entity import Entity
from homeassistant.loader import get_component
from homeassistant.components.http import HomeAssistantView
_LOGGER = logging.getLogger(__name__)
REQUIREMENTS = ["fitbit==0.2.2"]
@ -248,70 +249,83 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
redirect_uri = "{}{}".format(hass.config.api.base_url,
FITBIT_AUTH_CALLBACK_PATH)
def _start_fitbit_auth(handler, path_match, data):
"""Start Fitbit OAuth2 flow."""
url, _ = oauth.authorize_token_url(redirect_uri=redirect_uri,
scope=["activity", "heartrate",
"nutrition", "profile",
"settings", "sleep",
"weight"])
handler.send_response(301)
handler.send_header("Location", url)
handler.end_headers()
fitbit_auth_start_url, _ = oauth.authorize_token_url(
redirect_uri=redirect_uri,
scope=["activity", "heartrate", "nutrition", "profile",
"settings", "sleep", "weight"])
def _finish_fitbit_auth(handler, path_match, data):
"""Finish Fitbit OAuth2 flow."""
response_message = """Fitbit has been successfully authorized!
You can close this window now!"""
from oauthlib.oauth2.rfc6749.errors import MismatchingStateError
from oauthlib.oauth2.rfc6749.errors import MissingTokenError
if data.get("code") is not None:
try:
oauth.fetch_access_token(data.get("code"), redirect_uri)
except MissingTokenError as error:
_LOGGER.error("Missing token: %s", error)
response_message = """Something went wrong when
attempting authenticating with Fitbit. The error
encountered was {}. Please try again!""".format(error)
except MismatchingStateError as error:
_LOGGER.error("Mismatched state, CSRF error: %s", error)
response_message = """Something went wrong when
attempting authenticating with Fitbit. The error
encountered was {}. Please try again!""".format(error)
else:
_LOGGER.error("Unknown error when authing")
response_message = """Something went wrong when
attempting authenticating with Fitbit.
An unknown error occurred. Please try again!
"""
html_response = """<html><head><title>Fitbit Auth</title></head>
<body><h1>{}</h1></body></html>""".format(response_message)
html_response = html_response.encode("utf-8")
handler.send_response(HTTP_OK)
handler.write_content(html_response, content_type="text/html")
config_contents = {
"access_token": oauth.token["access_token"],
"refresh_token": oauth.token["refresh_token"],
"client_id": oauth.client_id,
"client_secret": oauth.client_secret
}
if not config_from_file(config_path, config_contents):
_LOGGER.error("failed to save config file")
setup_platform(hass, config, add_devices, discovery_info=None)
hass.http.register_path("GET", FITBIT_AUTH_START, _start_fitbit_auth,
require_auth=False)
hass.http.register_path("GET", FITBIT_AUTH_CALLBACK_PATH,
_finish_fitbit_auth, require_auth=False)
hass.wsgi.register_redirect(FITBIT_AUTH_START, fitbit_auth_start_url)
hass.wsgi.register_view(FitbitAuthCallbackView(hass, config,
add_devices, oauth))
request_oauth_completion(hass)
class FitbitAuthCallbackView(HomeAssistantView):
"""Handle OAuth finish callback requests."""
requires_auth = False
url = '/auth/fitbit/callback'
name = 'auth:fitbit:callback'
def __init__(self, hass, config, add_devices, oauth):
"""Initialize the OAuth callback view."""
super().__init__(hass)
self.config = config
self.add_devices = add_devices
self.oauth = oauth
def get(self, request):
"""Finish OAuth callback request."""
from oauthlib.oauth2.rfc6749.errors import MismatchingStateError
from oauthlib.oauth2.rfc6749.errors import MissingTokenError
data = request.args
response_message = """Fitbit has been successfully authorized!
You can close this window now!"""
if data.get("code") is not None:
redirect_uri = "{}{}".format(self.hass.config.api.base_url,
FITBIT_AUTH_CALLBACK_PATH)
try:
self.oauth.fetch_access_token(data.get("code"), redirect_uri)
except MissingTokenError as error:
_LOGGER.error("Missing token: %s", error)
response_message = """Something went wrong when
attempting authenticating with Fitbit. The error
encountered was {}. Please try again!""".format(error)
except MismatchingStateError as error:
_LOGGER.error("Mismatched state, CSRF error: %s", error)
response_message = """Something went wrong when
attempting authenticating with Fitbit. The error
encountered was {}. Please try again!""".format(error)
else:
_LOGGER.error("Unknown error when authing")
response_message = """Something went wrong when
attempting authenticating with Fitbit.
An unknown error occurred. Please try again!
"""
html_response = """<html><head><title>Fitbit Auth</title></head>
<body><h1>{}</h1></body></html>""".format(response_message)
config_contents = {
"access_token": self.oauth.token["access_token"],
"refresh_token": self.oauth.token["refresh_token"],
"client_id": self.oauth.client_id,
"client_secret": self.oauth.client_secret
}
if not config_from_file(self.hass.config.path(FITBIT_CONFIG_FILE),
config_contents):
_LOGGER.error("failed to save config file")
setup_platform(self.hass, self.config, self.add_devices)
return html_response
# pylint: disable=too-few-public-methods
class FitbitSensor(Entity):
"""Implementation of a Fitbit sensor."""

46
homeassistant/components/sensor/torque.py
View file

@ -7,8 +7,8 @@ https://home-assistant.io/components/sensor.torque/
import re
from homeassistant.const import HTTP_OK
from homeassistant.helpers.entity import Entity
from homeassistant.components.http import HomeAssistantView
DOMAIN = 'torque'
DEPENDENCIES = ['http']
@ -43,12 +43,31 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
email = config.get('email', None)
sensors = {}
def _receive_data(handler, path_match, data):
"""Received data from Torque."""
handler.send_response(HTTP_OK)
handler.end_headers()
hass.wsgi.register_view(TorqueReceiveDataView(hass, email, vehicle,
sensors, add_devices))
return True
if email is not None and email != data[SENSOR_EMAIL_FIELD]:
class TorqueReceiveDataView(HomeAssistantView):
"""Handle data from Torque requests."""
url = API_PATH
name = 'api:torque'
# pylint: disable=too-many-arguments
def __init__(self, hass, email, vehicle, sensors, add_devices):
"""Initialize a Torque view."""
super().__init__(hass)
self.email = email
self.vehicle = vehicle
self.sensors = sensors
self.add_devices = add_devices
def get(self, request):
"""Handle Torque data request."""
data = request.args
if self.email is not None and self.email != data[SENSOR_EMAIL_FIELD]:
return
names = {}
@ -66,18 +85,17 @@ def setup_platform(hass, config, add_devices, discovery_info=None):
units[pid] = decode(data[key])
elif is_value:
pid = convert_pid(is_value.group(1))
if pid in sensors:
sensors[pid].on_update(data[key])
if pid in self.sensors:
self.sensors[pid].on_update(data[key])
for pid in names:
if pid not in sensors:
sensors[pid] = TorqueSensor(
ENTITY_NAME_FORMAT.format(vehicle, names[pid]),
if pid not in self.sensors:
self.sensors[pid] = TorqueSensor(
ENTITY_NAME_FORMAT.format(self.vehicle, names[pid]),
units.get(pid, None))
add_devices([sensors[pid]])
self.add_devices([self.sensors[pid]])
hass.http.register_path('GET', API_PATH, _receive_data)
return True
return None
class TorqueSensor(Entity):

4
homeassistant/helpers/event.py
View file

@ -186,8 +186,8 @@ def track_utc_time_change(hass, action, year=None, month=None, day=None,
def track_time_change(hass, action, year=None, month=None, day=None,
hour=None, minute=None, second=None):
"""Add a listener that will fire if UTC time matches a pattern."""
track_utc_time_change(hass, action, year, month, day, hour, minute, second,
local=True)
return track_utc_time_change(hass, action, year, month, day, hour, minute,
second, local=True)
def _process_match_param(parameter):

15
homeassistant/remote.py
View file

@ -21,7 +21,8 @@ import homeassistant.core as ha
from homeassistant.const import (
HTTP_HEADER_HA_AUTH, SERVER_PORT, URL_API, URL_API_EVENT_FORWARD,
URL_API_EVENTS, URL_API_EVENTS_EVENT, URL_API_SERVICES,
URL_API_SERVICES_SERVICE, URL_API_STATES, URL_API_STATES_ENTITY)
URL_API_SERVICES_SERVICE, URL_API_STATES, URL_API_STATES_ENTITY,
HTTP_HEADER_CONTENT_TYPE, CONTENT_TYPE_JSON)
from homeassistant.exceptions import HomeAssistantError
METHOD_GET = "get"
@ -59,7 +60,9 @@ class API(object):
else:
self.base_url = "http://{}:{}".format(host, self.port)
self.status = None
self._headers = {}
self._headers = {
HTTP_HEADER_CONTENT_TYPE: CONTENT_TYPE_JSON,
}
if api_password is not None:
self._headers[HTTP_HEADER_HA_AUTH] = api_password
@ -126,7 +129,7 @@ class HomeAssistant(ha.HomeAssistant):
def start(self):
"""Start the instance."""
# Ensure a local API exists to connect with remote
if self.config.api is None:
if 'api' not in self.config.components:
if not bootstrap.setup_component(self, 'api'):
raise HomeAssistantError(
'Unable to setup local API to receive events')
@ -136,6 +139,10 @@ class HomeAssistant(ha.HomeAssistant):
self.bus.fire(ha.EVENT_HOMEASSISTANT_START,
origin=ha.EventOrigin.remote)
# Give eventlet time to startup
import eventlet
eventlet.sleep(0.1)
# Setup that events from remote_api get forwarded to local_api
# Do this after we fire START, otherwise HTTP is not started
if not connect_remote_events(self.remote_api, self.config.api):
@ -383,7 +390,7 @@ def fire_event(api, event_type, data=None):
req = api(METHOD_POST, URL_API_EVENTS_EVENT.format(event_type), data)
if req.status_code != 200:
_LOGGER.error("Error firing event: %d - %d",
_LOGGER.error("Error firing event: %d - %s",
req.status_code, req.text)
except HomeAssistantError:

9
requirements_all.txt
View file

@ -23,6 +23,9 @@ SoCo==0.11.1
# homeassistant.components.notify.twitter
TwitterAPI==2.4.1
# homeassistant.components.http
Werkzeug==0.11.5
# homeassistant.components.apcupsd
apcaccess==0.0.4
@ -53,6 +56,9 @@ dweepy==0.2.0
# homeassistant.components.sensor.eliqonline
eliqonline==1.0.12
# homeassistant.components.http
eventlet==0.18.4
# homeassistant.components.thermostat.honeywell
evohomeclient==0.2.5
@ -331,6 +337,9 @@ somecomfort==0.2.1
# homeassistant.components.sensor.speedtest
speedtest-cli==0.3.4
# homeassistant.components.http
static3==0.7.0
# homeassistant.components.sensor.steam_online
steamodd==4.21

1
script/build_frontend
View file

@ -8,6 +8,7 @@ npm run frontend_prod
cp bower_components/webcomponentsjs/webcomponents-lite.min.js ..
cp build/frontend.html ..
cp build/service_worker.js ..
gzip build/frontend.html -c -k -9 > ../frontend.html.gz
# Generate the MD5 hash of the new frontend
cd ../..

6
script/update_mdi.py
View file

@ -1,6 +1,7 @@
#!/usr/bin/env python3
"""Download the latest Polymer v1 iconset for materialdesignicons.com."""
import hashlib
import gzip
import os
import re
import requests
@ -16,6 +17,7 @@ CUR_VERSION = re.compile(r'VERSION = "([A-Za-z0-9]{32})"')
OUTPUT_BASE = os.path.join('homeassistant', 'components', 'frontend')
VERSION_OUTPUT = os.path.join(OUTPUT_BASE, 'mdi_version.py')
ICONSET_OUTPUT = os.path.join(OUTPUT_BASE, 'www_static', 'mdi.html')
ICONSET_OUTPUT_GZ = os.path.join(OUTPUT_BASE, 'www_static', 'mdi.html.gz')
def get_local_version():
@ -58,6 +60,10 @@ def write_component(version, source):
print('Writing icons to', ICONSET_OUTPUT)
outp.write(source)
with gzip.open(ICONSET_OUTPUT_GZ, 'wb') as outp:
print('Writing icons gz to', ICONSET_OUTPUT_GZ)
outp.write(source.encode('utf-8'))
with open(VERSION_OUTPUT, 'w') as outp:
print('Generating version file', VERSION_OUTPUT)
outp.write(

10
tests/common.py
View file

@ -120,7 +120,7 @@ def mock_state_change_event(hass, new_state, old_state=None):
def mock_http_component(hass):
"""Mock the HTTP component."""
hass.http = MockHTTP()
hass.wsgi = mock.MagicMock()
hass.config.components.append('http')
@ -135,14 +135,6 @@ def mock_mqtt_component(hass, mock_mqtt):
return mock_mqtt
class MockHTTP(object):
"""Mock the HTTP module."""
def register_path(self, method, url, callback, require_auth=True):
"""Register a path."""
pass
class MockModule(object):
"""Representation of a fake module."""

2
tests/components/device_tracker/test_locative.py
View file

@ -2,6 +2,7 @@
import unittest
from unittest.mock import patch
import eventlet
import requests
from homeassistant import bootstrap, const
@ -45,6 +46,7 @@ def setUpModule(): # pylint: disable=invalid-name
})
hass.start()
eventlet.sleep(0.05)
def tearDownModule(): # pylint: disable=invalid-name

8
tests/components/test_alexa.py
View file

@ -3,6 +3,7 @@
import unittest
import json
import eventlet
import requests
from homeassistant import bootstrap, const
@ -13,7 +14,10 @@ from tests.common import get_test_instance_port, get_test_home_assistant
API_PASSWORD = "test1234"
SERVER_PORT = get_test_instance_port()
API_URL = "http://127.0.0.1:{}{}".format(SERVER_PORT, alexa.API_ENDPOINT)
HA_HEADERS = {const.HTTP_HEADER_HA_AUTH: API_PASSWORD}
HA_HEADERS = {
const.HTTP_HEADER_HA_AUTH: API_PASSWORD,
const.HTTP_HEADER_CONTENT_TYPE: const.CONTENT_TYPE_JSON,
}
SESSION_ID = 'amzn1.echo-api.session.0000000-0000-0000-0000-00000000000'
APPLICATION_ID = 'amzn1.echo-sdk-ams.app.000000-d0ed-0000-ad00-000000d00ebe'
@ -83,6 +87,8 @@ def setUpModule(): # pylint: disable=invalid-name
hass.start()
eventlet.sleep(0.1)
def tearDownModule(): # pylint: disable=invalid-name
"""Stop the Home Assistant server."""

152
tests/components/test_api.py
View file

@ -1,11 +1,12 @@
"""The tests for the Home Assistant HTTP component."""
# pylint: disable=protected-access,too-many-public-methods
from contextlib import closing
# from contextlib import closing
import json
import tempfile
import unittest
from unittest.mock import patch
import eventlet
import requests
from homeassistant import bootstrap, const
@ -17,7 +18,10 @@ from tests.common import get_test_instance_port, get_test_home_assistant
API_PASSWORD = "test1234"
SERVER_PORT = get_test_instance_port()
HTTP_BASE_URL = "http://127.0.0.1:{}".format(SERVER_PORT)
HA_HEADERS = {const.HTTP_HEADER_HA_AUTH: API_PASSWORD}
HA_HEADERS = {
const.HTTP_HEADER_HA_AUTH: API_PASSWORD,
const.HTTP_HEADER_CONTENT_TYPE: const.CONTENT_TYPE_JSON,
}
hass = None
@ -45,6 +49,10 @@ def setUpModule(): # pylint: disable=invalid-name
hass.start()
# To start HTTP
# TODO fix this
eventlet.sleep(0.05)
def tearDownModule(): # pylint: disable=invalid-name
"""Stop the Home Assistant server."""
@ -80,15 +88,6 @@ class TestAPI(unittest.TestCase):
self.assertEqual(200, req.status_code)
def test_access_via_session(self):
"""Test access wia session."""
session = requests.Session()
req = session.get(_url(const.URL_API), headers=HA_HEADERS)
self.assertEqual(200, req.status_code)
req = session.get(_url(const.URL_API))
self.assertEqual(200, req.status_code)
def test_api_list_state_entities(self):
"""Test if the debug interface allows us to list state entities."""
req = requests.get(_url(const.URL_API_STATES),
@ -220,7 +219,7 @@ class TestAPI(unittest.TestCase):
hass.pool.block_till_done()
self.assertEqual(422, req.status_code)
self.assertEqual(400, req.status_code)
self.assertEqual(0, len(test_value))
# Try now with valid but unusable JSON
@ -231,7 +230,7 @@ class TestAPI(unittest.TestCase):
hass.pool.block_till_done()
self.assertEqual(422, req.status_code)
self.assertEqual(400, req.status_code)
self.assertEqual(0, len(test_value))
def test_api_get_config(self):
@ -333,8 +332,7 @@ class TestAPI(unittest.TestCase):
req = requests.post(
_url(const.URL_API_TEMPLATE),
data=json.dumps({"template":
'{{ states.sensor.temperature.state }}'}),
json={"template": '{{ states.sensor.temperature.state }}'},
headers=HA_HEADERS)
self.assertEqual('10', req.text)
@ -349,7 +347,7 @@ class TestAPI(unittest.TestCase):
'{{ states.sensor.temperature.state'}),
headers=HA_HEADERS)
self.assertEqual(422, req.status_code)
self.assertEqual(400, req.status_code)
def test_api_event_forward(self):
"""Test setting up event forwarding."""
@ -390,23 +388,25 @@ class TestAPI(unittest.TestCase):
headers=HA_HEADERS)
self.assertEqual(422, req.status_code)
# Setup a real one
req = requests.post(
_url(const.URL_API_EVENT_FORWARD),
data=json.dumps({
'api_password': API_PASSWORD,
'host': '127.0.0.1',
'port': SERVER_PORT
}),
headers=HA_HEADERS)
self.assertEqual(200, req.status_code)
# TODO disabled because eventlet cannot validate
# a connection to itself, need a second instance
# # Setup a real one
# req = requests.post(
# _url(const.URL_API_EVENT_FORWARD),
# data=json.dumps({
# 'api_password': API_PASSWORD,
# 'host': '127.0.0.1',
# 'port': SERVER_PORT
# }),
# headers=HA_HEADERS)
# self.assertEqual(200, req.status_code)
# Delete it again..
req = requests.delete(
_url(const.URL_API_EVENT_FORWARD),
data=json.dumps({}),
headers=HA_HEADERS)
self.assertEqual(400, req.status_code)
# # Delete it again..
# req = requests.delete(
# _url(const.URL_API_EVENT_FORWARD),
# data=json.dumps({}),
# headers=HA_HEADERS)
# self.assertEqual(400, req.status_code)
req = requests.delete(
_url(const.URL_API_EVENT_FORWARD),
@ -426,63 +426,57 @@ class TestAPI(unittest.TestCase):
headers=HA_HEADERS)
self.assertEqual(200, req.status_code)
def test_stream(self):
"""Test the stream."""
listen_count = self._listen_count()
with closing(requests.get(_url(const.URL_API_STREAM),
stream=True, headers=HA_HEADERS)) as req:
# def test_stream(self):
# """Test the stream."""
# listen_count = self._listen_count()
# with closing(requests.get(_url(const.URL_API_STREAM), timeout=3,
# stream=True, headers=HA_HEADERS)) as req:
data = self._stream_next_event(req)
self.assertEqual('ping', data)
# self.assertEqual(listen_count + 2, self._listen_count())
self.assertEqual(listen_count + 1, self._listen_count())
# hass.bus.fire('test_event')
hass.bus.fire('test_event')
hass.pool.block_till_done()
# data = self._stream_next_event(req)
data = self._stream_next_event(req)
# self.assertEqual('test_event', data['event_type'])
self.assertEqual('test_event', data['event_type'])
# def test_stream_with_restricted(self):
# """Test the stream with restrictions."""
# listen_count = self._listen_count()
# url = _url('{}?restrict=test_event1,test_event3'.format(
# const.URL_API_STREAM))
# with closing(requests.get(url, stream=True, timeout=3,
# headers=HA_HEADERS)) as req:
# self.assertEqual(listen_count + 3, self._listen_count())
def test_stream_with_restricted(self):
"""Test the stream with restrictions."""
listen_count = self._listen_count()
with closing(requests.get(_url(const.URL_API_STREAM),
data=json.dumps({
'restrict': 'test_event1,test_event3'}),
stream=True, headers=HA_HEADERS)) as req:
# hass.bus.fire('test_event1')
# data = self._stream_next_event(req)
# self.assertEqual('test_event1', data['event_type'])
data = self._stream_next_event(req)
self.assertEqual('ping', data)
# hass.bus.fire('test_event2')
# hass.bus.fire('test_event3')
self.assertEqual(listen_count + 2, self._listen_count())
# data = self._stream_next_event(req)
# self.assertEqual('test_event3', data['event_type'])
hass.bus.fire('test_event1')
hass.pool.block_till_done()
hass.bus.fire('test_event2')
hass.pool.block_till_done()
hass.bus.fire('test_event3')
hass.pool.block_till_done()
# def _stream_next_event(self, stream):
# """Read the stream for next event while ignoring ping."""
# while True:
# data = b''
# last_new_line = False
# for dat in stream.iter_content(1):
# if dat == b'\n' and last_new_line:
# break
# data += dat
# last_new_line = dat == b'\n'
data = self._stream_next_event(req)
self.assertEqual('test_event1', data['event_type'])
data = self._stream_next_event(req)
self.assertEqual('test_event3', data['event_type'])
# conv = data.decode('utf-8').strip()[6:]
def _stream_next_event(self, stream):
"""Test the stream for next event."""
data = b''
last_new_line = False
for dat in stream.iter_content(1):
if dat == b'\n' and last_new_line:
break
data += dat
last_new_line = dat == b'\n'
# if conv != 'ping':
# break
conv = data.decode('utf-8').strip()[6:]
# return json.loads(conv)
return conv if conv == 'ping' else json.loads(conv)
def _listen_count(self):
"""Return number of event listeners."""
return sum(hass.bus.listeners.values())
# def _listen_count(self):
# """Return number of event listeners."""
# return sum(hass.bus.listeners.values())

5
tests/components/test_frontend.py
View file

@ -3,6 +3,7 @@
import re
import unittest
import eventlet
import requests
import homeassistant.bootstrap as bootstrap
@ -42,6 +43,10 @@ def setUpModule(): # pylint: disable=invalid-name
hass.start()
# Give eventlet time to start
# TODO fix this
eventlet.sleep(0.05)
def tearDownModule(): # pylint: disable=invalid-name
"""Stop everything that was started."""

2
tests/components/test_logbook.py
View file

@ -12,7 +12,7 @@ from homeassistant.components import logbook
from tests.common import mock_http_component, get_test_home_assistant
class TestComponentHistory(unittest.TestCase):
class TestComponentLogbook(unittest.TestCase):
"""Test the History component."""
def setUp(self):

16
tests/test_remote.py
View file

@ -2,6 +2,8 @@
# pylint: disable=protected-access,too-many-public-methods
import unittest
import eventlet
import homeassistant.core as ha
import homeassistant.bootstrap as bootstrap
import homeassistant.remote as remote
@ -46,6 +48,10 @@ def setUpModule(): # pylint: disable=invalid-name
hass.start()
# Give eventlet time to start
# TODO fix this
eventlet.sleep(0.05)
master_api = remote.API("127.0.0.1", API_PASSWORD, MASTER_PORT)
# Start slave
@ -57,6 +63,10 @@ def setUpModule(): # pylint: disable=invalid-name
slave.start()
# Give eventlet time to start
# TODO fix this
eventlet.sleep(0.05)
def tearDownModule(): # pylint: disable=invalid-name
"""Stop the Home Assistant server and slave."""
@ -232,6 +242,7 @@ class TestRemoteClasses(unittest.TestCase):
slave.pool.block_till_done()
# Wait till master gives updated state
hass.pool.block_till_done()
eventlet.sleep(0.01)
self.assertEqual("remote.statemachine test",
slave.states.get("remote.test").state)
@ -240,11 +251,13 @@ class TestRemoteClasses(unittest.TestCase):
"""Remove statemachine from master."""
hass.states.set("remote.master_remove", "remove me!")
hass.pool.block_till_done()
eventlet.sleep(0.01)
self.assertIn('remote.master_remove', slave.states.entity_ids())
hass.states.remove("remote.master_remove")
hass.pool.block_till_done()
eventlet.sleep(0.01)
self.assertNotIn('remote.master_remove', slave.states.entity_ids())
@ -252,12 +265,14 @@ class TestRemoteClasses(unittest.TestCase):
"""Remove statemachine from slave."""
hass.states.set("remote.slave_remove", "remove me!")
hass.pool.block_till_done()
eventlet.sleep(0.01)
self.assertIn('remote.slave_remove', slave.states.entity_ids())
self.assertTrue(slave.states.remove("remote.slave_remove"))
slave.pool.block_till_done()
hass.pool.block_till_done()
eventlet.sleep(0.01)
self.assertNotIn('remote.slave_remove', slave.states.entity_ids())
@ -276,5 +291,6 @@ class TestRemoteClasses(unittest.TestCase):
slave.pool.block_till_done()
# Wait till master gives updated event
hass.pool.block_till_done()
eventlet.sleep(0.01)
self.assertEqual(1, len(test_value))