EventBus is now Bus that handles Events and Services

This commit is contained in:
Paulus Schoutsen committed 2013-11-19 23:48:08 -08:00
1 parent 05e68c3e1e
commit 3641d2ca24
10 files changed
+592 -225

No files matched your search

+119 -64
View File
@@ -15,8 +15,12 @@ from datetime import datetime
logging.basicConfig(level=logging.INFO)
ALL_EVENTS = '*'
DOMAIN_HOMEASSISTANT = "homeassistant"
SERVICE_HOMEASSISTANT_STOP = "stop"
EVENT_HOMEASSISTANT_START = "homeassistant.start"
EVENT_HOMEASSISTANT_STOP = "homeassistant.stop"
EVENT_STATE_CHANGED = "state_changed"
EVENT_TIME_CHANGED = "time_changed"
@@ -30,16 +34,16 @@ assert 60 % TIMER_INTERVAL == 0, "60 % TIMER_INTERVAL should be 0!"
DATE_STR_FORMAT = "%H:%M:%S %d-%m-%Y"
def start_home_assistant(eventbus):
def start_home_assistant(bus):
""" Start home assistant. """
request_shutdown = threading.Event()
eventbus.listen_once(EVENT_HOMEASSISTANT_STOP,
lambda event: request_shutdown.set())
bus.register_service(DOMAIN_HOMEASSISTANT, SERVICE_HOMEASSISTANT_STOP,
lambda service: request_shutdown.set())
Timer(eventbus)
Timer(bus)
eventbus.fire(EVENT_HOMEASSISTANT_START)
bus.fire_event(EVENT_HOMEASSISTANT_START)
while True:
try:
@@ -68,7 +72,7 @@ def str_to_datetime(dt_str):
return datetime.strptime(dt_str, DATE_STR_FORMAT)
def ensure_list(parameter):
def _ensure_list(parameter):
""" Wraps parameter in a list if it is not one and returns it.
@rtype : list
@@ -76,7 +80,7 @@ def ensure_list(parameter):
return parameter if isinstance(parameter, list) else [parameter]
def matcher(subject, pattern):
def _matcher(subject, pattern):
""" Returns True if subject matches the pattern.
Pattern is either a list of allowed subjects or a '*'.
@@ -95,33 +99,35 @@ def create_state(state, attributes=None, last_changed=None):
'last_changed': datetime_to_str(last_changed)}
def track_state_change(eventbus, category, from_state, to_state, action):
def track_state_change(bus, category, from_state, to_state, action):
""" Helper method to track specific state changes. """
from_state = ensure_list(from_state)
to_state = ensure_list(to_state)
from_state = _ensure_list(from_state)
to_state = _ensure_list(to_state)
def listener(event):
""" State change listener that listens for specific state changes. """
if category == event.data['category'] and \
matcher(event.data['old_state']['state'], from_state) and \
matcher(event.data['new_state']['state'], to_state):
_matcher(event.data['old_state']['state'], from_state) and \
_matcher(event.data['new_state']['state'], to_state):
action(event.data['category'],
event.data['old_state'],
event.data['new_state'])
eventbus.listen(EVENT_STATE_CHANGED, listener)
bus.listen_event(EVENT_STATE_CHANGED, listener)
# pylint: disable=too-many-arguments
def track_time_change(eventbus, action,
def track_time_change(bus, action,
year='*', month='*', day='*',
hour='*', minute='*', second='*',
point_in_time=None, listen_once=False):
""" Adds a listener that will listen for a specified or matching time. """
year, month, day = ensure_list(year), ensure_list(month), ensure_list(day)
hour, minute = ensure_list(hour), ensure_list(minute)
second = ensure_list(second)
year, month = _ensure_list(year), _ensure_list(month)
day = _ensure_list(day)
hour, minute = _ensure_list(hour), _ensure_list(minute)
second = _ensure_list(second)
def listener(event):
""" Listens for matching time_changed events. """
@@ -129,47 +135,92 @@ def track_time_change(eventbus, action,
if (point_in_time and now > point_in_time) or \
(not point_in_time and
matcher(now.year, year) and
matcher(now.month, month) and
matcher(now.day, day) and
matcher(now.hour, hour) and
matcher(now.minute, minute) and
matcher(now.second, second)):
_matcher(now.year, year) and
_matcher(now.month, month) and
_matcher(now.day, day) and
_matcher(now.hour, hour) and
_matcher(now.minute, minute) and
_matcher(now.second, second)):
# point_in_time are exact points in time
# so we always remove it after fire
if listen_once or point_in_time:
event.eventbus.remove_listener(EVENT_TIME_CHANGED, listener)
event.bus.remove_event_listener(EVENT_TIME_CHANGED, listener)
action(now)
eventbus.listen(EVENT_TIME_CHANGED, listener)
bus.listen_event(EVENT_TIME_CHANGED, listener)
ServiceCall = namedtuple("ServiceCall", ["bus", "domain", "service", "data"])
Event = namedtuple("Event", ["bus", "event_type", "data"])
Event = namedtuple("Event", ["eventbus", "event_type", "data"])
class EventBus(object):
""" Class that allows code to listen for- and fire events. """
class Bus(object):
""" Class that allows different components to communicate via services
and events.
"""
def __init__(self):
self._listeners = defaultdict(list)
self._event_listeners = defaultdict(list)
self._services = {}
self.logger = logging.getLogger(__name__)
@property
def listeners(self):
""" List of events that is being listened for. """
return {key: len(self._listeners[key])
for key in self._listeners.keys()
if len(self._listeners[key]) > 0}
def services(self):
""" Dict with per domain a list of available services. """
return {domain: self._services[domain].keys()
for domain in self._services}
def fire(self, event_type, event_data=None):
@property
def event_listeners(self):
""" Dict with events that is being listened for and the number
of listeners.
"""
return {key: len(self._event_listeners[key])
for key in self._event_listeners.keys()
if len(self._event_listeners[key]) > 0}
def call_service(self, domain, service, service_data=None):
""" Calls a service. """
try:
self._services[domain][service]
except KeyError:
# Domain or Service does not exist
raise ServiceDoesNotExistException(
"Service does not exist: {}/{}".format(domain, service))
if not service_data:
service_data = {}
def run():
""" Executes a service. """
service_call = ServiceCall(self, domain, service, service_data)
try:
self._services[domain][service](service_call)
except Exception: # pylint: disable=broad-except
self.logger.exception("Bus:Exception in service {}/{}".format(
domain, service))
# We dont want the eventbus to be blocking - run in a thread.
threading.Thread(target=run).start()
def register_service(self, domain, service, service_callback):
""" Register a service. """
try:
self._services[domain][service] = service_callback
except KeyError:
# Domain does not exist yet
self._services[domain] = {service: service_callback}
def fire_event(self, event_type, event_data=None):
""" Fire an event. """
if not event_data:
event_data = {}
self.logger.info("EventBus:Event {}: {}".format(
self.logger.info("Bus:Event {}: {}".format(
event_type, event_data))
def run():
@@ -178,26 +229,26 @@ class EventBus(object):
# We do not use itertools.chain() because some listeners might
# choose to remove themselves as a listener while being executed
for listener in self._listeners[ALL_EVENTS] + \
self._listeners[event.event_type]:
for listener in self._event_listeners[ALL_EVENTS] + \
self._event_listeners[event.event_type]:
try:
listener(event)
except Exception: # pylint: disable=broad-except
self.logger.exception("EventBus:Exception in listener")
self.logger.exception("Bus:Exception in event listener")
# We dont want the eventbus to be blocking - run in a thread.
# We dont want the bus to be blocking - run in a thread.
threading.Thread(target=run).start()
def listen(self, event_type, listener):
def listen_event(self, event_type, listener):
""" Listen for all events or events of a specific type.
To listen to all events specify the constant ``ALL_EVENTS``
as event_type.
"""
self._listeners[event_type].append(listener)
self._event_listeners[event_type].append(listener)
def listen_once(self, event_type, listener):
def listen_once_event(self, event_type, listener):
""" Listen once for event of a specific type.
To listen to all events specify the constant ``ALL_EVENTS``
@@ -208,19 +259,19 @@ class EventBus(object):
def onetime_listener(event):
""" Removes listener from eventbus and then fires listener. """
self.remove_listener(event_type, onetime_listener)
self.remove_event_listener(event_type, onetime_listener)
listener(event)
self.listen(event_type, onetime_listener)
self.listen_event(event_type, onetime_listener)
def remove_listener(self, event_type, listener):
def remove_event_listener(self, event_type, listener):
""" Removes a listener of a specific event_type. """
try:
self._listeners[event_type].remove(listener)
self._event_listeners[event_type].remove(listener)
if len(self._listeners[event_type]) == 0:
del self._listeners[event_type]
if len(self._event_listeners[event_type]) == 0:
del self._event_listeners[event_type]
except ValueError:
pass
@@ -229,9 +280,9 @@ class EventBus(object):
class StateMachine(object):
""" Helper class that tracks the state of different categories. """
def __init__(self, eventbus):
def __init__(self, bus):
self.states = dict()
self.eventbus = eventbus
self.bus = bus
self.lock = threading.Lock()
@property
@@ -274,10 +325,10 @@ class StateMachine(object):
self.states[category] = create_state(new_state, attributes)
self.eventbus.fire(EVENT_STATE_CHANGED,
{'category': category,
'old_state': old_state,
'new_state': self.states[category]})
self.bus.fire_event(EVENT_STATE_CHANGED,
{'category': category,
'old_state': old_state,
'new_state': self.states[category]})
self.lock.release()
@@ -302,14 +353,14 @@ class StateMachine(object):
class Timer(threading.Thread):
""" Timer will sent out an event every TIMER_INTERVAL seconds. """
def __init__(self, eventbus):
def __init__(self, bus):
threading.Thread.__init__(self)
self.daemon = True
self.eventbus = eventbus
self.bus = bus
eventbus.listen_once(EVENT_HOMEASSISTANT_START,
lambda event: self.start())
bus.listen_once_event(EVENT_HOMEASSISTANT_START,
lambda event: self.start())
def run(self):
""" Start the timer. """
@@ -338,9 +389,13 @@ class Timer(threading.Thread):
last_fired_on_second = now.second
self.eventbus.fire(EVENT_TIME_CHANGED,
{'now': datetime_to_str(now)})
self.bus.fire_event(EVENT_TIME_CHANGED,
{'now': datetime_to_str(now)})
class HomeAssistantException(Exception):
""" General Home Assistant exception occured. """
class ServiceDoesNotExistException(HomeAssistantException):
""" A service has been referenced that deos not exist. """