def mock_psc(hass, config_input, domain):
"""Mock the prepare_setup_component to capture config."""
res = async_process_component_config(hass, config_input, domain)
config[domain] = None if res is None else res.get(domain)
_LOGGER.debug("Configuration for %s, Validated: %s, Original %s",
domain, config[domain], config_input.get(domain))
return res
def mock_psc(hass, config_input, domain):
"""Mock the prepare_setup_component to capture config."""
res = async_process_component_config(
hass, config_input, domain)
config[domain] = None if res is None else res.get(domain)
_LOGGER.debug("Configuration for %s, Validated: %s, Original %s",
domain, config[domain], config_input.get(domain))
return res
def async_prepare_reload(self):
"""Prepare reloading this entity component.
This method must be run in the event loop.
"""
try:
conf = yield from \
conf_util.async_hass_config_yaml(self.hass)
except HomeAssistantError as err:
self.logger.error(err)
return None
conf = conf_util.async_process_component_config(
self.hass, conf, self.domain)
if conf is None:
return None
yield from self.async_reset()
return conf
async def async_prepare_reload(self):
"""Prepare reloading this entity component.
This method must be run in the event loop.
"""
try:
conf = await \
conf_util.async_hass_config_yaml(self.hass)
except HomeAssistantError as err:
self.logger.error(err)
return None
conf = conf_util.async_process_component_config(
self.hass, conf, self.domain)
if conf is None:
return None
await self._async_reset()
return conf
async def _async_setup_component(hass: core.HomeAssistant, domain: str,
config) -> bool:
"""Set up a component for Home Assistant.
This method is a coroutine.
"""
def log_error(msg, link=True):
"""Log helper."""
_LOGGER.error("Setup failed for %s: %s", domain, msg)
async_notify_setup_error(hass, domain, link)
component = loader.get_component(hass, domain)
if not component:
log_error("Component not found.", False)
return False
# Validate no circular dependencies
components = loader.load_order_component(hass, domain)
# OrderedSet is empty if component or dependencies could not be resolved
if not components:
log_error("Unable to resolve component or dependencies.")
return False
processed_config = \
conf_util.async_process_component_config(hass, config, domain)
if processed_config is None:
log_error("Invalid config.")
return False
try:
await async_process_deps_reqs(hass, config, domain, component)
except HomeAssistantError as err:
log_error(str(err))
return False
start = timer()
_LOGGER.info("Setting up %s", domain)
if hasattr(component, 'PLATFORM_SCHEMA'):
# Entity components have their own warning
warn_task = None
else:
warn_task = hass.loop.call_later(
SLOW_SETUP_WARNING, _LOGGER.warning,
"Setup of %s is taking over %s seconds.", domain,
SLOW_SETUP_WARNING)
try:
if hasattr(component, 'async_setup'):
result = await component.async_setup( # type: ignore
hass, processed_config)
else:
result = await hass.async_add_job(component.setup, hass,
processed_config) # type: ignore
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Error during setup of component %s", domain)
async_notify_setup_error(hass, domain, True)
return False
finally:
end = timer()
if warn_task:
warn_task.cancel()
_LOGGER.info("Setup of domain %s took %.1f seconds.", domain, end - start)
if result is False:
log_error("Component failed to initialize.")
return False
elif result is not True:
log_error("Component did not return boolean if setup was successful. "
"Disabling component.")
loader.set_component(hass, domain, None)
return False
for entry in hass.config_entries.async_entries(domain):
await entry.async_setup(hass, component=component)
hass.config.components.add(component.DOMAIN) # type: ignore
# Cleanup
if domain in hass.data[DATA_SETUP]:
hass.data[DATA_SETUP].pop(domain)
hass.bus.async_fire(
EVENT_COMPONENT_LOADED,
{ATTR_COMPONENT: component.DOMAIN} # type: ignore
)
return True
def _async_setup_component(hass: core.HomeAssistant, domain: str,
config) -> bool:
"""Set up a component for Home Assistant.
This method is a coroutine.
"""
def log_error(msg, link=True):
"""Log helper."""
_LOGGER.error("Setup failed for %s: %s", domain, msg)
async_notify_setup_error(hass, domain, link)
component = loader.get_component(domain)
if not component:
log_error("Component not found.", False)
return False
# Validate no circular dependencies
components = loader.load_order_component(domain)
# OrderedSet is empty if component or dependencies could not be resolved
if not components:
log_error("Unable to resolve component or dependencies.")
return False
processed_config = \
conf_util.async_process_component_config(hass, config, domain)
if processed_config is None:
log_error("Invalid config.")
return False
if not hass.config.skip_pip and hasattr(component, 'REQUIREMENTS'):
req_success = yield from _async_process_requirements(
hass, domain, component.REQUIREMENTS)
if not req_success:
log_error("Could not install all requirements.")
return False
if hasattr(component, 'DEPENDENCIES'):
dep_success = yield from _async_process_dependencies(
hass, config, domain, component.DEPENDENCIES)
if not dep_success:
log_error("Could not setup all dependencies.")
return False
async_comp = hasattr(component, 'async_setup')
_LOGGER.info("Setting up %s", domain)
warn_task = hass.loop.call_later(SLOW_SETUP_WARNING, _LOGGER.warning,
"Setup of %s is taking over %s seconds.",
domain, SLOW_SETUP_WARNING)
try:
if async_comp:
result = yield from component.async_setup(hass, processed_config)
else:
result = yield from hass.loop.run_in_executor(
None, component.setup, hass, processed_config)
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Error during setup of component %s", domain)
async_notify_setup_error(hass, domain, True)
return False
finally:
warn_task.cancel()
if result is False:
log_error("Component failed to initialize.")
return False
elif result is not True:
log_error("Component did not return boolean if setup was successful. "
"Disabling component.")
loader.set_component(domain, None)
return False
hass.config.components.add(component.DOMAIN)
# Cleanup
if domain in hass.data[DATA_SETUP]:
hass.data[DATA_SETUP].pop(domain)
hass.bus.async_fire(EVENT_COMPONENT_LOADED,
{ATTR_COMPONENT: component.DOMAIN})
return True
def _async_setup_component(hass: core.HomeAssistant,
domain: str, config) -> bool:
"""Set up a component for Home Assistant.
This method is a coroutine.
"""
def log_error(msg, link=True):
"""Log helper."""
_LOGGER.error("Setup failed for %s: %s", domain, msg)
async_notify_setup_error(hass, domain, link)
component = loader.get_component(domain)
if not component:
log_error("Component not found.", False)
return False
# Validate no circular dependencies
components = loader.load_order_component(domain)
# OrderedSet is empty if component or dependencies could not be resolved
if not components:
log_error("Unable to resolve component or dependencies.")
return False
processed_config = \
conf_util.async_process_component_config(hass, config, domain)
if processed_config is None:
log_error("Invalid config.")
return False
try:
yield from async_process_deps_reqs(hass, config, domain, component)
except HomeAssistantError as err:
log_error(str(err))
return False
start = timer()
_LOGGER.info("Setting up %s", domain)
if hasattr(component, 'PLATFORM_SCHEMA'):
# Entity components have their own warning
warn_task = None
else:
warn_task = hass.loop.call_later(
SLOW_SETUP_WARNING, _LOGGER.warning,
"Setup of %s is taking over %s seconds.",
domain, SLOW_SETUP_WARNING)
try:
if hasattr(component, 'async_setup'):
result = yield from component.async_setup(hass, processed_config)
else:
result = yield from hass.async_add_job(
component.setup, hass, processed_config)
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Error during setup of component %s", domain)
async_notify_setup_error(hass, domain, True)
return False
finally:
end = timer()
if warn_task:
warn_task.cancel()
_LOGGER.info("Setup of domain %s took %.1f seconds.", domain, end - start)
if result is False:
log_error("Component failed to initialize.")
return False
elif result is not True:
log_error("Component did not return boolean if setup was successful. "
"Disabling component.")
loader.set_component(domain, None)
return False
for entry in hass.config_entries.async_entries(domain):
yield from entry.async_setup(hass, component=component)
hass.config.components.add(component.DOMAIN)
# Cleanup
if domain in hass.data[DATA_SETUP]:
hass.data[DATA_SETUP].pop(domain)
hass.bus.async_fire(
EVENT_COMPONENT_LOADED, {ATTR_COMPONENT: component.DOMAIN}
)
return True
def _async_setup_component(hass: core.HomeAssistant,
domain: str, config) -> bool:
"""Setup a component for Home Assistant.
This method is a coroutine.
hass: Home Assistant instance.
domain: Domain of component to setup.
config: The Home Assistant configuration.
"""
def log_error(msg, link=True):
"""Log helper."""
_LOGGER.error('Setup failed for %s: %s', domain, msg)
async_notify_setup_error(hass, domain, link)
component = loader.get_component(domain)
if not component:
log_error('Component not found.', False)
return False
# Validate no circular dependencies
components = loader.load_order_component(domain)
# OrderedSet is empty if component or dependencies could not be resolved
if not components:
log_error('Unable to resolve component or dependencies.')
return False
processed_config = \
conf_util.async_process_component_config(hass, config, domain)
if processed_config is None:
log_error('Invalid config.')
return False
if not hass.config.skip_pip and hasattr(component, 'REQUIREMENTS'):
req_success = yield from _async_process_requirements(
hass, domain, component.REQUIREMENTS)
if not req_success:
log_error('Could not install all requirements.')
return False
if hasattr(component, 'DEPENDENCIES'):
dep_success = yield from _async_process_dependencies(
hass, config, domain, component.DEPENDENCIES)
if not dep_success:
log_error('Could not setup all dependencies.')
return False
async_comp = hasattr(component, 'async_setup')
_LOGGER.info("Setting up %s", domain)
warn_task = hass.loop.call_later(
SLOW_SETUP_WARNING, _LOGGER.warning,
'Setup of %s is taking over %s seconds.', domain, SLOW_SETUP_WARNING)
try:
if async_comp:
result = yield from component.async_setup(hass, processed_config)
else:
result = yield from hass.loop.run_in_executor(
None, component.setup, hass, processed_config)
except Exception: # pylint: disable=broad-except
_LOGGER.exception('Error during setup of component %s', domain)
async_notify_setup_error(hass, domain, True)
return False
finally:
warn_task.cancel()
if result is False:
log_error('Component failed to initialize.')
return False
elif result is not True:
log_error('Component did not return boolean if setup was successful. '
'Disabling component.')
loader.set_component(domain, None)
return False
hass.config.components.add(component.DOMAIN)
# cleanup
if domain in hass.data[DATA_SETUP]:
hass.data[DATA_SETUP].pop(domain)
hass.bus.async_fire(
EVENT_COMPONENT_LOADED, {ATTR_COMPONENT: component.DOMAIN}
)
return True
async def _async_setup_component(hass: core.HomeAssistant,
domain: str, config: Dict) -> bool:
"""Set up a component for Home Assistant.
This method is a coroutine.
"""
def log_error(msg: str, link: bool = True) -> None:
"""Log helper."""
_LOGGER.error("Setup failed for %s: %s", domain, msg)
async_notify_setup_error(hass, domain, link)
component = loader.get_component(hass, domain)
if not component:
log_error("Component not found.", False)
return False
# Validate all dependencies exist and there are no circular dependencies
try:
loader.component_dependencies(hass, domain)
except loader.ComponentNotFound as err:
_LOGGER.error(
"Not setting up %s because we are unable to resolve "
"(sub)dependency %s", domain, err.domain)
return False
except loader.CircularDependency as err:
_LOGGER.error(
"Not setting up %s because it contains a circular dependency: "
"%s -> %s", domain, err.from_domain, err.to_domain)
return False
processed_config = \
conf_util.async_process_component_config(hass, config, domain)
if processed_config is None:
log_error("Invalid config.")
return False
try:
await async_process_deps_reqs(hass, config, domain, component)
except HomeAssistantError as err:
log_error(str(err))
return False
start = timer()
_LOGGER.info("Setting up %s", domain)
if hasattr(component, 'PLATFORM_SCHEMA'):
# Entity components have their own warning
warn_task = None
else:
warn_task = hass.loop.call_later(
SLOW_SETUP_WARNING, _LOGGER.warning,
"Setup of %s is taking over %s seconds.",
domain, SLOW_SETUP_WARNING)
try:
if hasattr(component, 'async_setup'):
result = await component.async_setup( # type: ignore
hass, processed_config)
else:
result = await hass.async_add_executor_job(
component.setup, hass, processed_config) # type: ignore
except Exception: # pylint: disable=broad-except
_LOGGER.exception("Error during setup of component %s", domain)
async_notify_setup_error(hass, domain, True)
return False
finally:
end = timer()
if warn_task:
warn_task.cancel()
_LOGGER.info("Setup of domain %s took %.1f seconds.", domain, end - start)
if result is False:
log_error("Component failed to initialize.")
return False
if result is not True:
log_error("Component {!r} did not return boolean if setup was "
"successful. Disabling component.".format(domain))
loader.set_component(hass, domain, None)
return False
if hass.config_entries:
for entry in hass.config_entries.async_entries(domain):
await entry.async_setup(hass, component=component)
hass.config.components.add(component.DOMAIN) # type: ignore
# Cleanup
if domain in hass.data[DATA_SETUP]:
hass.data[DATA_SETUP].pop(domain)
hass.bus.async_fire(
EVENT_COMPONENT_LOADED,
{ATTR_COMPONENT: component.DOMAIN} # type: ignore
)
return True
