Remove legacy script mode and simplify remaining modes (#37729)
This commit is contained in:
1 parent
8a8289b1a4
commit
63e55bff52
11 files changed
+407
-959
No files matched your search
+186
-484
@@ -1,12 +1,10 @@
|
||||
"""Helpers to execute scripts."""
|
||||
from abc import ABC, abstractmethod
|
||||
import asyncio
|
||||
from contextlib import suppress
|
||||
from datetime import datetime
|
||||
from functools import partial
|
||||
import itertools
|
||||
import logging
|
||||
from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple, cast
|
||||
from typing import Any, Callable, Dict, List, Optional, Sequence, Set, Tuple
|
||||
|
||||
from async_timeout import timeout
|
||||
import voluptuous as vol
|
||||
@@ -27,7 +25,6 @@ from homeassistant.const import (
|
||||
CONF_EVENT_DATA,
|
||||
CONF_EVENT_DATA_TEMPLATE,
|
||||
CONF_MODE,
|
||||
CONF_QUEUE_SIZE,
|
||||
CONF_REPEAT,
|
||||
CONF_SCENE,
|
||||
CONF_SEQUENCE,
|
||||
@@ -35,25 +32,15 @@ from homeassistant.const import (
|
||||
CONF_UNTIL,
|
||||
CONF_WAIT_TEMPLATE,
|
||||
CONF_WHILE,
|
||||
SERVICE_TURN_OFF,
|
||||
SERVICE_TURN_ON,
|
||||
)
|
||||
from homeassistant.core import (
|
||||
CALLBACK_TYPE,
|
||||
SERVICE_CALL_LIMIT,
|
||||
Context,
|
||||
HomeAssistant,
|
||||
callback,
|
||||
)
|
||||
from homeassistant.core import SERVICE_CALL_LIMIT, Context, HomeAssistant, callback
|
||||
from homeassistant.helpers import (
|
||||
condition,
|
||||
config_validation as cv,
|
||||
template as template,
|
||||
)
|
||||
from homeassistant.helpers.event import (
|
||||
async_track_point_in_utc_time,
|
||||
async_track_template,
|
||||
)
|
||||
from homeassistant.helpers.event import async_track_template
|
||||
from homeassistant.helpers.service import (
|
||||
CONF_SERVICE_DATA,
|
||||
async_prepare_call_from_config,
|
||||
@@ -64,74 +51,41 @@ from homeassistant.util.dt import utcnow
|
||||
|
||||
# mypy: allow-untyped-calls, allow-untyped-defs, no-check-untyped-defs
|
||||
|
||||
SCRIPT_MODE_ERROR = "error"
|
||||
SCRIPT_MODE_IGNORE = "ignore"
|
||||
SCRIPT_MODE_LEGACY = "legacy"
|
||||
SCRIPT_MODE_PARALLEL = "parallel"
|
||||
SCRIPT_MODE_QUEUE = "queue"
|
||||
SCRIPT_MODE_RESTART = "restart"
|
||||
SCRIPT_MODE_SINGLE = "single"
|
||||
SCRIPT_MODE_CHOICES = [
|
||||
SCRIPT_MODE_ERROR,
|
||||
SCRIPT_MODE_IGNORE,
|
||||
SCRIPT_MODE_LEGACY,
|
||||
SCRIPT_MODE_PARALLEL,
|
||||
SCRIPT_MODE_QUEUE,
|
||||
SCRIPT_MODE_RESTART,
|
||||
SCRIPT_MODE_SINGLE,
|
||||
]
|
||||
DEFAULT_SCRIPT_MODE = SCRIPT_MODE_LEGACY
|
||||
DEFAULT_SCRIPT_MODE = SCRIPT_MODE_SINGLE
|
||||
|
||||
DEFAULT_QUEUE_SIZE = 10
|
||||
CONF_MAX = "max"
|
||||
DEFAULT_MAX = 10
|
||||
|
||||
_LOG_EXCEPTION = logging.ERROR + 1
|
||||
_TIMEOUT_MSG = "Timeout reached, abort script."
|
||||
|
||||
SCRIPT_BASE_SCHEMA = vol.Schema(
|
||||
{
|
||||
vol.Optional(CONF_MODE): vol.In(SCRIPT_MODE_CHOICES),
|
||||
vol.Optional(CONF_QUEUE_SIZE): vol.All(vol.Coerce(int), vol.Range(min=2)),
|
||||
}
|
||||
)
|
||||
|
||||
_UNSUPPORTED_IN_LEGACY = {
|
||||
cv.SCRIPT_ACTION_REPEAT: CONF_REPEAT,
|
||||
}
|
||||
|
||||
|
||||
def warn_deprecated_legacy(logger, msg):
|
||||
"""Warn about deprecated legacy mode."""
|
||||
logger.warning(
|
||||
"Script behavior has changed. "
|
||||
"To continue using previous behavior, which is now deprecated, "
|
||||
"add '%s: %s' to %s.",
|
||||
CONF_MODE,
|
||||
SCRIPT_MODE_LEGACY,
|
||||
msg,
|
||||
def make_script_schema(schema, default_script_mode, extra=vol.PREVENT_EXTRA):
|
||||
"""Make a schema for a component that uses the script helper."""
|
||||
return vol.Schema(
|
||||
{
|
||||
**schema,
|
||||
vol.Optional(CONF_MODE, default=default_script_mode): vol.In(
|
||||
SCRIPT_MODE_CHOICES
|
||||
),
|
||||
vol.Optional(CONF_MAX, default=DEFAULT_MAX): vol.All(
|
||||
vol.Coerce(int), vol.Range(min=2)
|
||||
),
|
||||
},
|
||||
extra=extra,
|
||||
)
|
||||
|
||||
|
||||
def validate_legacy_mode_actions(sequence):
|
||||
"""Check for actions not supported in legacy mode."""
|
||||
for action in sequence:
|
||||
script_action = cv.determine_script_action(action)
|
||||
if script_action in _UNSUPPORTED_IN_LEGACY:
|
||||
raise vol.Invalid(
|
||||
f"{_UNSUPPORTED_IN_LEGACY[script_action]} action not supported in "
|
||||
f"{SCRIPT_MODE_LEGACY} mode"
|
||||
)
|
||||
|
||||
|
||||
def validate_queue_size(config):
|
||||
"""Validate queue_size option."""
|
||||
mode = config.get(CONF_MODE, DEFAULT_SCRIPT_MODE)
|
||||
queue_size = config.get(CONF_QUEUE_SIZE)
|
||||
if mode == SCRIPT_MODE_QUEUE:
|
||||
if queue_size is None:
|
||||
config[CONF_QUEUE_SIZE] = DEFAULT_QUEUE_SIZE
|
||||
elif queue_size is not None:
|
||||
raise vol.Invalid(f"{CONF_QUEUE_SIZE} not valid with {mode} {CONF_MODE}")
|
||||
return config
|
||||
|
||||
|
||||
async def async_validate_action_config(
|
||||
hass: HomeAssistant, config: ConfigType
|
||||
) -> ConfigType:
|
||||
@@ -159,20 +113,8 @@ class _StopScript(Exception):
|
||||
"""Throw if script needs to stop."""
|
||||
|
||||
|
||||
class _SuspendScript(Exception):
|
||||
"""Throw if script needs to suspend."""
|
||||
|
||||
|
||||
class AlreadyRunning(exceptions.HomeAssistantError):
|
||||
"""Throw if script already running and user wants error."""
|
||||
|
||||
|
||||
class QueueFull(exceptions.HomeAssistantError):
|
||||
"""Throw if script already running, user wants new run queued, but queue is full."""
|
||||
|
||||
|
||||
class _ScriptRunBase(ABC):
|
||||
"""Common data & methods for managing Script sequence run."""
|
||||
class _ScriptRun:
|
||||
"""Manage Script sequence run."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
@@ -189,17 +131,36 @@ class _ScriptRunBase(ABC):
|
||||
self._log_exceptions = log_exceptions
|
||||
self._step = -1
|
||||
self._action: Optional[Dict[str, Any]] = None
|
||||
self._stop = asyncio.Event()
|
||||
self._stopped = asyncio.Event()
|
||||
|
||||
def _changed(self):
|
||||
self._script._changed() # pylint: disable=protected-access
|
||||
if not self._stop.is_set():
|
||||
self._script._changed() # pylint: disable=protected-access
|
||||
|
||||
@property
|
||||
def _config_cache(self):
|
||||
return self._script._config_cache # pylint: disable=protected-access
|
||||
|
||||
@abstractmethod
|
||||
def _log(self, msg, *args, level=logging.INFO):
|
||||
self._script._log(msg, *args, level=level) # pylint: disable=protected-access
|
||||
|
||||
async def async_run(self) -> None:
|
||||
"""Run script."""
|
||||
try:
|
||||
if self._stop.is_set():
|
||||
return
|
||||
self._script.last_triggered = utcnow()
|
||||
self._changed()
|
||||
self._log("Running script")
|
||||
for self._step, self._action in enumerate(self._script.sequence):
|
||||
if self._stop.is_set():
|
||||
break
|
||||
await self._async_step(log_exceptions=False)
|
||||
except _StopScript:
|
||||
pass
|
||||
finally:
|
||||
self._finish()
|
||||
|
||||
async def _async_step(self, log_exceptions):
|
||||
try:
|
||||
@@ -207,15 +168,23 @@ class _ScriptRunBase(ABC):
|
||||
self, f"_async_{cv.determine_script_action(self._action)}_step"
|
||||
)()
|
||||
except Exception as ex:
|
||||
if not isinstance(
|
||||
ex, (_SuspendScript, _StopScript, asyncio.CancelledError)
|
||||
) and (self._log_exceptions or log_exceptions):
|
||||
if not isinstance(ex, (_StopScript, asyncio.CancelledError)) and (
|
||||
self._log_exceptions or log_exceptions
|
||||
):
|
||||
self._log_exception(ex)
|
||||
raise
|
||||
|
||||
@abstractmethod
|
||||
def _finish(self):
|
||||
self._script._runs.remove(self) # pylint: disable=protected-access
|
||||
if not self._script.is_running:
|
||||
self._script.last_action = None
|
||||
self._changed()
|
||||
self._stopped.set()
|
||||
|
||||
async def async_stop(self) -> None:
|
||||
"""Stop script run."""
|
||||
self._stop.set()
|
||||
await self._stopped.wait()
|
||||
|
||||
def _log_exception(self, exception):
|
||||
action_type = cv.determine_script_action(self._action)
|
||||
@@ -235,12 +204,6 @@ class _ScriptRunBase(ABC):
|
||||
elif isinstance(exception, exceptions.ServiceNotFound):
|
||||
error_desc = "Service not found"
|
||||
|
||||
elif isinstance(exception, AlreadyRunning):
|
||||
error_desc = "Already running"
|
||||
|
||||
elif isinstance(exception, QueueFull):
|
||||
error_desc = "Run queue is full"
|
||||
|
||||
else:
|
||||
error_desc = "Unexpected error"
|
||||
level = _LOG_EXCEPTION
|
||||
@@ -254,11 +217,8 @@ class _ScriptRunBase(ABC):
|
||||
level=level,
|
||||
)
|
||||
|
||||
@abstractmethod
|
||||
async def _async_delay_step(self):
|
||||
"""Handle delay."""
|
||||
|
||||
def _prep_delay_step(self):
|
||||
try:
|
||||
delay = vol.All(cv.time_period, cv.positive_timedelta)(
|
||||
template.render_complex(self._action[CONF_DELAY], self._variables)
|
||||
@@ -275,35 +235,128 @@ class _ScriptRunBase(ABC):
|
||||
self._script.last_action = self._action.get(CONF_ALIAS, f"delay {delay}")
|
||||
self._log("Executing step %s", self._script.last_action)
|
||||
|
||||
return delay
|
||||
delay = delay.total_seconds()
|
||||
self._changed()
|
||||
try:
|
||||
async with timeout(delay):
|
||||
await self._stop.wait()
|
||||
except asyncio.TimeoutError:
|
||||
pass
|
||||
|
||||
@abstractmethod
|
||||
async def _async_wait_template_step(self):
|
||||
"""Handle a wait template."""
|
||||
|
||||
def _prep_wait_template_step(self, async_script_wait):
|
||||
wait_template = self._action[CONF_WAIT_TEMPLATE]
|
||||
wait_template.hass = self._hass
|
||||
|
||||
self._script.last_action = self._action.get(CONF_ALIAS, "wait template")
|
||||
self._log("Executing step %s", self._script.last_action)
|
||||
|
||||
wait_template = self._action[CONF_WAIT_TEMPLATE]
|
||||
wait_template.hass = self._hass
|
||||
|
||||
# check if condition already okay
|
||||
if condition.async_template(self._hass, wait_template, self._variables):
|
||||
return None
|
||||
return
|
||||
|
||||
return async_track_template(
|
||||
@callback
|
||||
def async_script_wait(entity_id, from_s, to_s):
|
||||
"""Handle script after template condition is true."""
|
||||
done.set()
|
||||
|
||||
unsub = async_track_template(
|
||||
self._hass, wait_template, async_script_wait, self._variables
|
||||
)
|
||||
|
||||
@abstractmethod
|
||||
self._changed()
|
||||
try:
|
||||
delay = self._action[CONF_TIMEOUT].total_seconds()
|
||||
except KeyError:
|
||||
delay = None
|
||||
done = asyncio.Event()
|
||||
tasks = [
|
||||
self._hass.async_create_task(flag.wait()) for flag in (self._stop, done)
|
||||
]
|
||||
try:
|
||||
async with timeout(delay):
|
||||
await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
|
||||
except asyncio.TimeoutError:
|
||||
if not self._action.get(CONF_CONTINUE_ON_TIMEOUT, True):
|
||||
self._log(_TIMEOUT_MSG)
|
||||
raise _StopScript
|
||||
finally:
|
||||
for task in tasks:
|
||||
task.cancel()
|
||||
unsub()
|
||||
|
||||
async def _async_run_long_action(self, long_task):
|
||||
"""Run a long task while monitoring for stop request."""
|
||||
|
||||
async def async_cancel_long_task():
|
||||
# Stop long task and wait for it to finish.
|
||||
long_task.cancel()
|
||||
try:
|
||||
await long_task
|
||||
except Exception: # pylint: disable=broad-except
|
||||
pass
|
||||
|
||||
# Wait for long task while monitoring for a stop request.
|
||||
stop_task = self._hass.async_create_task(self._stop.wait())
|
||||
try:
|
||||
await asyncio.wait(
|
||||
{long_task, stop_task}, return_when=asyncio.FIRST_COMPLETED
|
||||
)
|
||||
# If our task is cancelled, then cancel long task, too. Note that if long task
|
||||
# is cancelled otherwise the CancelledError exception will not be raised to
|
||||
# here due to the call to asyncio.wait(). Rather we'll check for that below.
|
||||
except asyncio.CancelledError:
|
||||
await async_cancel_long_task()
|
||||
raise
|
||||
finally:
|
||||
stop_task.cancel()
|
||||
|
||||
if long_task.cancelled():
|
||||
raise asyncio.CancelledError
|
||||
if long_task.done():
|
||||
# Propagate any exceptions that occurred.
|
||||
long_task.result()
|
||||
else:
|
||||
# Stopped before long task completed, so cancel it.
|
||||
await async_cancel_long_task()
|
||||
|
||||
async def _async_call_service_step(self):
|
||||
"""Call the service specified in the action."""
|
||||
|
||||
def _prep_call_service_step(self):
|
||||
self._script.last_action = self._action.get(CONF_ALIAS, "call service")
|
||||
self._log("Executing step %s", self._script.last_action)
|
||||
return async_prepare_call_from_config(self._hass, self._action, self._variables)
|
||||
|
||||
domain, service, service_data = async_prepare_call_from_config(
|
||||
self._hass, self._action, self._variables
|
||||
)
|
||||
|
||||
running_script = (
|
||||
domain == "automation"
|
||||
and service == "trigger"
|
||||
or domain in ("python_script", "script")
|
||||
)
|
||||
# If this might start a script then disable the call timeout.
|
||||
# Otherwise use the normal service call limit.
|
||||
if running_script:
|
||||
limit = None
|
||||
else:
|
||||
limit = SERVICE_CALL_LIMIT
|
||||
|
||||
service_task = self._hass.async_create_task(
|
||||
self._hass.services.async_call(
|
||||
domain,
|
||||
service,
|
||||
service_data,
|
||||
blocking=True,
|
||||
context=self._context,
|
||||
limit=limit,
|
||||
)
|
||||
)
|
||||
if limit is not None:
|
||||
# There is a call limit, so just wait for it to finish.
|
||||
await service_task
|
||||
return
|
||||
|
||||
await self._async_run_long_action(service_task)
|
||||
|
||||
async def _async_device_step(self):
|
||||
"""Perform the device automation specified in the action."""
|
||||
@@ -370,175 +423,6 @@ class _ScriptRunBase(ABC):
|
||||
if not check:
|
||||
raise _StopScript
|
||||
|
||||
@abstractmethod
|
||||
async def _async_repeat_step(self):
|
||||
"""Repeat a sequence."""
|
||||
|
||||
def _log(self, msg, *args, level=logging.INFO):
|
||||
self._script._log(msg, *args, level=level) # pylint: disable=protected-access
|
||||
|
||||
|
||||
class _ScriptRun(_ScriptRunBase):
|
||||
"""Manage Script sequence run."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
hass: HomeAssistant,
|
||||
script: "Script",
|
||||
variables: Optional[Sequence],
|
||||
context: Optional[Context],
|
||||
log_exceptions: bool,
|
||||
) -> None:
|
||||
super().__init__(hass, script, variables, context, log_exceptions)
|
||||
self._stop = asyncio.Event()
|
||||
self._stopped = asyncio.Event()
|
||||
|
||||
def _changed(self):
|
||||
if not self._stop.is_set():
|
||||
super()._changed()
|
||||
|
||||
async def async_run(self) -> None:
|
||||
"""Run script."""
|
||||
try:
|
||||
if self._stop.is_set():
|
||||
return
|
||||
self._script.last_triggered = utcnow()
|
||||
self._changed()
|
||||
self._log("Running script")
|
||||
for self._step, self._action in enumerate(self._script.sequence):
|
||||
if self._stop.is_set():
|
||||
break
|
||||
await self._async_step(log_exceptions=False)
|
||||
except _StopScript:
|
||||
pass
|
||||
finally:
|
||||
self._finish()
|
||||
|
||||
def _finish(self):
|
||||
self._script._runs.remove(self) # pylint: disable=protected-access
|
||||
if not self._script.is_running:
|
||||
self._script.last_action = None
|
||||
self._changed()
|
||||
self._stopped.set()
|
||||
|
||||
async def async_stop(self) -> None:
|
||||
"""Stop script run."""
|
||||
self._stop.set()
|
||||
await self._stopped.wait()
|
||||
|
||||
async def _async_delay_step(self):
|
||||
"""Handle delay."""
|
||||
delay = self._prep_delay_step().total_seconds()
|
||||
self._changed()
|
||||
try:
|
||||
async with timeout(delay):
|
||||
await self._stop.wait()
|
||||
except asyncio.TimeoutError:
|
||||
pass
|
||||
|
||||
async def _async_wait_template_step(self):
|
||||
"""Handle a wait template."""
|
||||
|
||||
@callback
|
||||
def async_script_wait(entity_id, from_s, to_s):
|
||||
"""Handle script after template condition is true."""
|
||||
done.set()
|
||||
|
||||
unsub = self._prep_wait_template_step(async_script_wait)
|
||||
if not unsub:
|
||||
return
|
||||
|
||||
self._changed()
|
||||
try:
|
||||
delay = self._action[CONF_TIMEOUT].total_seconds()
|
||||
except KeyError:
|
||||
delay = None
|
||||
done = asyncio.Event()
|
||||
tasks = [
|
||||
self._hass.async_create_task(flag.wait()) for flag in (self._stop, done)
|
||||
]
|
||||
try:
|
||||
async with timeout(delay):
|
||||
await asyncio.wait(tasks, return_when=asyncio.FIRST_COMPLETED)
|
||||
except asyncio.TimeoutError:
|
||||
if not self._action.get(CONF_CONTINUE_ON_TIMEOUT, True):
|
||||
self._log(_TIMEOUT_MSG)
|
||||
raise _StopScript
|
||||
finally:
|
||||
for task in tasks:
|
||||
task.cancel()
|
||||
unsub()
|
||||
|
||||
async def _async_run_long_action(self, long_task):
|
||||
"""Run a long task while monitoring for stop request."""
|
||||
|
||||
async def async_cancel_long_task():
|
||||
# Stop long task and wait for it to finish.
|
||||
long_task.cancel()
|
||||
try:
|
||||
await long_task
|
||||
except Exception: # pylint: disable=broad-except
|
||||
pass
|
||||
|
||||
# Wait for long task while monitoring for a stop request.
|
||||
stop_task = self._hass.async_create_task(self._stop.wait())
|
||||
try:
|
||||
await asyncio.wait(
|
||||
{long_task, stop_task}, return_when=asyncio.FIRST_COMPLETED
|
||||
)
|
||||
# If our task is cancelled, then cancel long task, too. Note that if long task
|
||||
# is cancelled otherwise the CancelledError exception will not be raised to
|
||||
# here due to the call to asyncio.wait(). Rather we'll check for that below.
|
||||
except asyncio.CancelledError:
|
||||
await async_cancel_long_task()
|
||||
raise
|
||||
finally:
|
||||
stop_task.cancel()
|
||||
|
||||
if long_task.cancelled():
|
||||
raise asyncio.CancelledError
|
||||
if long_task.done():
|
||||
# Propagate any exceptions that occurred.
|
||||
long_task.result()
|
||||
else:
|
||||
# Stopped before long task completed, so cancel it.
|
||||
await async_cancel_long_task()
|
||||
|
||||
async def _async_call_service_step(self):
|
||||
"""Call the service specified in the action."""
|
||||
domain, service, service_data = self._prep_call_service_step()
|
||||
|
||||
running_script = (
|
||||
domain == "automation"
|
||||
and service == "trigger"
|
||||
or domain == "python_script"
|
||||
or domain == "script"
|
||||
and service != SERVICE_TURN_OFF
|
||||
)
|
||||
# If this might start a script then disable the call timeout.
|
||||
# Otherwise use the normal service call limit.
|
||||
if running_script:
|
||||
limit = None
|
||||
else:
|
||||
limit = SERVICE_CALL_LIMIT
|
||||
|
||||
service_task = self._hass.async_create_task(
|
||||
self._hass.services.async_call(
|
||||
domain,
|
||||
service,
|
||||
service_data,
|
||||
blocking=True,
|
||||
context=self._context,
|
||||
limit=limit,
|
||||
)
|
||||
)
|
||||
if limit is not None:
|
||||
# There is a call limit, so just wait for it to finish.
|
||||
await service_task
|
||||
return
|
||||
|
||||
await self._async_run_long_action(service_task)
|
||||
|
||||
async def _async_repeat_step(self):
|
||||
"""Repeat a sequence."""
|
||||
|
||||
@@ -638,165 +522,12 @@ class _QueuedScriptRun(_ScriptRun):
|
||||
|
||||
def _finish(self):
|
||||
# pylint: disable=protected-access
|
||||
self._script._queue_len -= 1
|
||||
if self.lock_acquired:
|
||||
self._script._queue_lck.release()
|
||||
self.lock_acquired = False
|
||||
super()._finish()
|
||||
|
||||
|
||||
class _LegacyScriptRun(_ScriptRunBase):
|
||||
"""Manage legacy Script sequence run."""
|
||||
|
||||
def __init__(
|
||||
self,
|
||||
hass: HomeAssistant,
|
||||
script: "Script",
|
||||
variables: Optional[Sequence],
|
||||
context: Optional[Context],
|
||||
log_exceptions: bool,
|
||||
shared: Optional["_LegacyScriptRun"],
|
||||
) -> None:
|
||||
super().__init__(hass, script, variables, context, log_exceptions)
|
||||
if shared:
|
||||
self._shared = shared
|
||||
else:
|
||||
# To implement legacy behavior we need to share the following "run state"
|
||||
# amongst all runs, so it will only exist in the first instantiation of
|
||||
# concurrent runs, and the rest will use it, too.
|
||||
self._current = -1
|
||||
self._async_listeners: List[CALLBACK_TYPE] = []
|
||||
self._shared = self
|
||||
|
||||
@property
|
||||
def _cur(self):
|
||||
return self._shared._current # pylint: disable=protected-access
|
||||
|
||||
@_cur.setter
|
||||
def _cur(self, value):
|
||||
self._shared._current = value # pylint: disable=protected-access
|
||||
|
||||
@property
|
||||
def _async_listener(self):
|
||||
return self._shared._async_listeners # pylint: disable=protected-access
|
||||
|
||||
async def async_run(self) -> None:
|
||||
"""Run script."""
|
||||
await self._async_run()
|
||||
|
||||
async def _async_run(self, propagate_exceptions=True):
|
||||
if self._cur == -1:
|
||||
self._script.last_triggered = utcnow()
|
||||
self._log("Running script")
|
||||
self._cur = 0
|
||||
|
||||
# Unregister callback if we were in a delay or wait but turn on is
|
||||
# called again. In that case we just continue execution.
|
||||
self._async_remove_listener()
|
||||
|
||||
suspended = False
|
||||
try:
|
||||
for self._step, self._action in itertools.islice(
|
||||
enumerate(self._script.sequence), self._cur, None
|
||||
):
|
||||
await self._async_step(log_exceptions=not propagate_exceptions)
|
||||
except _StopScript:
|
||||
pass
|
||||
except _SuspendScript:
|
||||
# Store next step to take and notify change listeners
|
||||
self._cur = self._step + 1
|
||||
suspended = True
|
||||
return
|
||||
except Exception: # pylint: disable=broad-except
|
||||
if propagate_exceptions:
|
||||
raise
|
||||
finally:
|
||||
_cur_was = self._cur
|
||||
if not suspended:
|
||||
self._script.last_action = None
|
||||
await self.async_stop()
|
||||
if _cur_was != -1:
|
||||
self._changed()
|
||||
|
||||
async def async_stop(self) -> None:
|
||||
"""Stop script run."""
|
||||
if self._cur == -1:
|
||||
return
|
||||
|
||||
self._cur = -1
|
||||
self._async_remove_listener()
|
||||
self._script._runs.clear() # pylint: disable=protected-access
|
||||
|
||||
async def _async_delay_step(self):
|
||||
"""Handle delay."""
|
||||
delay = self._prep_delay_step()
|
||||
|
||||
@callback
|
||||
def async_script_delay(now):
|
||||
"""Handle delay."""
|
||||
with suppress(ValueError):
|
||||
self._async_listener.remove(unsub)
|
||||
self._hass.async_create_task(self._async_run(False))
|
||||
|
||||
unsub = async_track_point_in_utc_time(
|
||||
self._hass, async_script_delay, utcnow() + delay
|
||||
)
|
||||
self._async_listener.append(unsub)
|
||||
raise _SuspendScript
|
||||
|
||||
async def _async_wait_template_step(self):
|
||||
"""Handle a wait template."""
|
||||
|
||||
@callback
|
||||
def async_script_wait(entity_id, from_s, to_s):
|
||||
"""Handle script after template condition is true."""
|
||||
self._async_remove_listener()
|
||||
self._hass.async_create_task(self._async_run(False))
|
||||
|
||||
@callback
|
||||
def async_script_timeout(now):
|
||||
"""Call after timeout has expired."""
|
||||
with suppress(ValueError):
|
||||
self._async_listener.remove(unsub_timeout)
|
||||
|
||||
# Check if we want to continue to execute
|
||||
# the script after the timeout
|
||||
if self._action.get(CONF_CONTINUE_ON_TIMEOUT, True):
|
||||
self._hass.async_create_task(self._async_run(False))
|
||||
else:
|
||||
self._log(_TIMEOUT_MSG)
|
||||
self._hass.async_create_task(self.async_stop())
|
||||
|
||||
unsub_wait = self._prep_wait_template_step(async_script_wait)
|
||||
if not unsub_wait:
|
||||
return
|
||||
self._async_listener.append(unsub_wait)
|
||||
|
||||
if CONF_TIMEOUT in self._action:
|
||||
unsub_timeout = async_track_point_in_utc_time(
|
||||
self._hass, async_script_timeout, utcnow() + self._action[CONF_TIMEOUT]
|
||||
)
|
||||
self._async_listener.append(unsub_timeout)
|
||||
|
||||
raise _SuspendScript
|
||||
|
||||
async def _async_call_service_step(self):
|
||||
"""Call the service specified in the action."""
|
||||
await self._hass.services.async_call(
|
||||
*self._prep_call_service_step(), blocking=True, context=self._context
|
||||
)
|
||||
|
||||
async def _async_repeat_step(self):
|
||||
"""Repeat a sequence."""
|
||||
# Not supported in legacy mode.
|
||||
|
||||
def _async_remove_listener(self):
|
||||
"""Remove listeners, if any."""
|
||||
for unsub in self._async_listener:
|
||||
unsub()
|
||||
self._async_listener.clear()
|
||||
|
||||
|
||||
class Script:
|
||||
"""Representation of a script."""
|
||||
|
||||
@@ -807,7 +538,7 @@ class Script:
|
||||
name: Optional[str] = None,
|
||||
change_listener: Optional[Callable[..., Any]] = None,
|
||||
script_mode: str = DEFAULT_SCRIPT_MODE,
|
||||
queue_size: int = DEFAULT_QUEUE_SIZE,
|
||||
max_runs: int = DEFAULT_MAX,
|
||||
logger: Optional[logging.Logger] = None,
|
||||
log_exceptions: bool = True,
|
||||
) -> None:
|
||||
@@ -829,10 +560,7 @@ class Script:
|
||||
|
||||
self.last_action = None
|
||||
self.last_triggered: Optional[datetime] = None
|
||||
self.can_cancel = not self.is_legacy or any(
|
||||
CONF_DELAY in action or CONF_WAIT_TEMPLATE in action
|
||||
for action in self.sequence
|
||||
)
|
||||
self.can_cancel = True
|
||||
|
||||
self._repeat_script = {}
|
||||
for step, action in enumerate(sequence):
|
||||
@@ -850,10 +578,9 @@ class Script:
|
||||
)
|
||||
self._repeat_script[step] = sub_script
|
||||
|
||||
self._runs: List[_ScriptRunBase] = []
|
||||
self._runs: List[_ScriptRun] = []
|
||||
self._max_runs = max_runs
|
||||
if script_mode == SCRIPT_MODE_QUEUE:
|
||||
self._queue_size = queue_size
|
||||
self._queue_len = 0
|
||||
self._queue_lck = asyncio.Lock()
|
||||
self._config_cache: Dict[Set[Tuple], Callable[..., bool]] = {}
|
||||
self._referenced_entities: Optional[Set[str]] = None
|
||||
@@ -873,11 +600,6 @@ class Script:
|
||||
"""Return true if script is on."""
|
||||
return len(self._runs) > 0
|
||||
|
||||
@property
|
||||
def is_legacy(self) -> bool:
|
||||
"""Return if using legacy mode."""
|
||||
return self._script_mode == SCRIPT_MODE_LEGACY
|
||||
|
||||
@property
|
||||
def referenced_devices(self):
|
||||
"""Return a set of referenced devices."""
|
||||
@@ -945,60 +667,40 @@ class Script:
|
||||
) -> None:
|
||||
"""Run script."""
|
||||
if self.is_running:
|
||||
if self._script_mode == SCRIPT_MODE_IGNORE:
|
||||
self._log("Skipping script")
|
||||
if self._script_mode == SCRIPT_MODE_SINGLE:
|
||||
self._log("Already running", level=logging.WARNING)
|
||||
return
|
||||
if self._script_mode == SCRIPT_MODE_RESTART:
|
||||
self._log("Restarting")
|
||||
await self.async_stop(update_state=False)
|
||||
elif len(self._runs) == self._max_runs:
|
||||
self._log("Maximum number of runs exceeded", level=logging.WARNING)
|
||||
return
|
||||
|
||||
if self._script_mode == SCRIPT_MODE_ERROR:
|
||||
raise AlreadyRunning
|
||||
|
||||
if self._script_mode == SCRIPT_MODE_RESTART:
|
||||
self._log("Restarting script")
|
||||
await self.async_stop(update_state=False)
|
||||
elif self._script_mode == SCRIPT_MODE_QUEUE:
|
||||
self._log(
|
||||
"Queueing script behind %i run%s",
|
||||
self._queue_len,
|
||||
"s" if self._queue_len > 1 else "",
|
||||
)
|
||||
if self._queue_len >= self._queue_size:
|
||||
raise QueueFull
|
||||
|
||||
if self.is_legacy:
|
||||
if self._runs:
|
||||
shared = cast(Optional[_LegacyScriptRun], self._runs[0])
|
||||
else:
|
||||
shared = None
|
||||
run: _ScriptRunBase = _LegacyScriptRun(
|
||||
self._hass, self, variables, context, self._log_exceptions, shared
|
||||
)
|
||||
if self._script_mode != SCRIPT_MODE_QUEUE:
|
||||
cls = _ScriptRun
|
||||
else:
|
||||
if self._script_mode != SCRIPT_MODE_QUEUE:
|
||||
cls = _ScriptRun
|
||||
else:
|
||||
cls = _QueuedScriptRun
|
||||
self._queue_len += 1
|
||||
run = cls(self._hass, self, variables, context, self._log_exceptions)
|
||||
cls = _QueuedScriptRun
|
||||
run = cls(self._hass, self, variables, context, self._log_exceptions)
|
||||
self._runs.append(run)
|
||||
|
||||
try:
|
||||
if self.is_legacy:
|
||||
await run.async_run()
|
||||
else:
|
||||
await asyncio.shield(run.async_run())
|
||||
await asyncio.shield(run.async_run())
|
||||
except asyncio.CancelledError:
|
||||
await run.async_stop()
|
||||
self._changed()
|
||||
raise
|
||||
|
||||
async def async_stop(self, update_state: bool = True) -> None:
|
||||
"""Stop running script."""
|
||||
if not self.is_running:
|
||||
return
|
||||
await asyncio.shield(asyncio.gather(*(run.async_stop() for run in self._runs)))
|
||||
async def _async_stop(self, update_state):
|
||||
await asyncio.wait([run.async_stop() for run in self._runs])
|
||||
if update_state:
|
||||
self._changed()
|
||||
|
||||
async def async_stop(self, update_state: bool = True) -> None:
|
||||
"""Stop running script."""
|
||||
if self.is_running:
|
||||
await asyncio.shield(self._async_stop(update_state))
|
||||
|
||||
def _log(self, msg, *args, level=logging.INFO):
|
||||
if self.name:
|
||||
msg = f"%s: {msg}"
|
||||
|
||||
Reference in new issue
Block a user