131 lines
4.1 KiB
Python
131 lines
4.1 KiB
Python
"""
|
|
homeassistant.bootstrap
|
|
~~~~~~~~~~~~~~~~~~~~~~~
|
|
Provides methods to bootstrap a home assistant instance.
|
|
|
|
Each method will return a tuple (bus, statemachine).
|
|
|
|
After bootstrapping you can add your own components or
|
|
start by calling homeassistant.start_home_assistant(bus)
|
|
"""
|
|
|
|
import os
|
|
import configparser
|
|
import logging
|
|
from collections import defaultdict
|
|
|
|
import homeassistant
|
|
import homeassistant.loader as loader
|
|
import homeassistant.components as core_components
|
|
|
|
|
|
# pylint: disable=too-many-branches, too-many-statements
|
|
def from_config_dict(config, hass=None):
|
|
"""
|
|
Tries to configure Home Assistant from a config dict.
|
|
|
|
Dynamically loads required components and its dependencies.
|
|
"""
|
|
if hass is None:
|
|
hass = homeassistant.HomeAssistant()
|
|
|
|
logger = logging.getLogger(__name__)
|
|
|
|
loader.prepare(hass)
|
|
|
|
# Make a copy because we are mutating it.
|
|
# Convert it to defaultdict so components can always have config dict
|
|
config = defaultdict(dict, config)
|
|
|
|
# Filter out the repeating and common config section [homeassistant]
|
|
components = (key for key in config.keys()
|
|
if ' ' not in key and key != homeassistant.DOMAIN)
|
|
|
|
if not core_components.setup(hass, config):
|
|
logger.error(("Home Assistant core failed to initialize. "
|
|
"Further initialization aborted."))
|
|
|
|
return hass
|
|
|
|
logger.info("Home Assistant core initialized")
|
|
|
|
# Setup the components
|
|
|
|
# We assume that all components that load before the group component loads
|
|
# are components that poll devices. As their tasks are IO based, we will
|
|
# add an extra worker for each of them.
|
|
add_worker = True
|
|
|
|
for domain in loader.load_order_components(components):
|
|
component = loader.get_component(domain)
|
|
|
|
try:
|
|
if component.setup(hass, config):
|
|
logger.info("component %s initialized", domain)
|
|
|
|
add_worker = add_worker and domain != "group"
|
|
|
|
if add_worker:
|
|
hass.pool.add_worker()
|
|
|
|
else:
|
|
logger.error("component %s failed to initialize", domain)
|
|
|
|
except Exception: # pylint: disable=broad-except
|
|
logger.exception("Error during setup of component %s", domain)
|
|
|
|
return hass
|
|
|
|
|
|
def from_config_file(config_path, hass=None, enable_logging=True):
|
|
"""
|
|
Reads the configuration file and tries to start all the required
|
|
functionality. Will add functionality to 'hass' parameter if given,
|
|
instantiates a new Home Assistant object if 'hass' is not given.
|
|
"""
|
|
if hass is None:
|
|
hass = homeassistant.HomeAssistant()
|
|
|
|
# Set config dir to directory holding config file
|
|
hass.config_dir = os.path.abspath(os.path.dirname(config_path))
|
|
|
|
if enable_logging:
|
|
# Setup the logging for home assistant.
|
|
logging.basicConfig(level=logging.INFO)
|
|
|
|
# Log errors to a file if we have write access to file or config dir
|
|
err_log_path = hass.get_config_path("home-assistant.log")
|
|
err_path_exists = os.path.isfile(err_log_path)
|
|
|
|
# Check if we can write to the error log if it exists or that
|
|
# we can create files in the containgin directory if not.
|
|
if (err_path_exists and os.access(err_log_path, os.W_OK)) or \
|
|
(not err_path_exists and os.access(hass.config_dir, os.W_OK)):
|
|
|
|
err_handler = logging.FileHandler(
|
|
err_log_path, mode='w', delay=True)
|
|
|
|
err_handler.setLevel(logging.WARNING)
|
|
err_handler.setFormatter(
|
|
logging.Formatter('%(asctime)s %(name)s: %(message)s',
|
|
datefmt='%H:%M %d-%m-%y'))
|
|
logging.getLogger('').addHandler(err_handler)
|
|
|
|
else:
|
|
logging.getLogger(__name__).error(
|
|
"Unable to setup error log %s (access denied)", err_log_path)
|
|
|
|
# Read config
|
|
config = configparser.ConfigParser()
|
|
config.read(config_path)
|
|
|
|
config_dict = {}
|
|
|
|
for section in config.sections():
|
|
config_dict[section] = {}
|
|
|
|
for key, val in config.items(section):
|
|
config_dict[section][key] = val
|
|
|
|
return from_config_dict(config_dict, hass)
|