Add asyncio lock to prevent parallel calls

Author: raman325

custom_components/lock_code_manager/__init__.py

@@ -123,7 +123,8 @@ async def _hard_refresh_usercodes(service: ServiceCall) -> None:
         _LOGGER.debug("Hard refresh usercodes service called: %s", service.data)
         locks = get_locks_from_targets(hass, service.data)
         results = await asyncio.gather(
-            *(lock.async_hard_refresh_codes() for lock in locks), return_exceptions=True
+            *(lock.async_internal_hard_refresh_codes() for lock in locks),
+            return_exceptions=True,
         )
         errors = [err for err in results if isinstance(err, Exception)]
         if errors:
@@ -404,7 +405,7 @@ async def async_update_listener(hass: HomeAssistant, config_entry: ConfigEntry)
             # Make sure lock is up before we proceed
             timeout = 1
 
-            while not await lock.async_is_connection_up():
+            while not await lock.async_internal_is_connection_up():
                 _LOGGER.debug(
                     (
                         "%s (%s): Lock %s is not connected to Home Assistant yet, waiting %s "

custom_components/lock_code_manager/binary_sensor.py

@@ -346,7 +346,7 @@ async def _async_update_state(
                 ) is not None and pin_state != self._get_entity_state(ATTR_CODE):
                     self._attr_is_on = False
                     self.async_write_ha_state()
-                    await self.lock.async_set_usercode(
+                    await self.lock.async_internal_set_usercode(
                         int(self.slot_num), pin_state, self._get_entity_state(CONF_NAME)
                     )
                     _LOGGER.info(
@@ -364,7 +364,7 @@ async def _async_update_state(
                 if self._get_entity_state(ATTR_CODE) != "":
                     self._attr_is_on = False
                     self.async_write_ha_state()
-                    await self.lock.async_clear_usercode(int(self.slot_num))
+                    await self.lock.async_internal_clear_usercode(int(self.slot_num))
                     _LOGGER.info(
                         "%s (%s): Cleared usercode for lock %s slot %s",
                         self.config_entry.entry_id,

custom_components/lock_code_manager/coordinator.py

@@ -32,7 +32,7 @@ def __init__(self, hass: HomeAssistant, lock: BaseLock) -> None:
     async def async_get_usercodes(self) -> dict[int, int | str]:
         """Update usercodes."""
         try:
-            return await self._lock.async_get_usercodes()
+            return await self._lock.async_internal_get_usercodes()
         except LockDisconnected as err:
             # We can silently fail if we've never been able to retrieve data
             if not self.data:

custom_components/lock_code_manager/providers/_base.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import asyncio
 from dataclasses import dataclass, field
 from datetime import timedelta
 import functools
@@ -50,6 +51,7 @@ class BaseLock:
     lock_config_entry: ConfigEntry | None = field(repr=False)
     lock: er.RegistryEntry
     device_entry: dr.DeviceEntry | None = field(default=None, init=False)
+    _aio_lock: asyncio.Lock = field(default_factory=asyncio.Lock, init=False)
 
     @final
     @callback
@@ -110,6 +112,11 @@ async def async_is_connection_up(self) -> bool:
         """Return whether connection to lock is up."""
         return await self.hass.async_add_executor_job(self.is_connection_up)
 
+    @final
+    async def async_internal_is_connection_up(self) -> bool:
+        """Return whether connection to lock is up."""
+        return await self.async_is_connection_up()
+
     def hard_refresh_codes(self) -> None:
         """
         Perform hard refresh all codes.
@@ -128,6 +135,17 @@ async def async_hard_refresh_codes(self) -> None:
         """
         await self.hass.async_add_executor_job(self.hard_refresh_codes)
 
+    @final
+    async def async_internal_hard_refresh_codes(self) -> None:
+        """
+        Perform hard refresh of all codes.
+
+        Needed for integrations where usercodes are cached and may get out of sync with
+        the lock.
+        """
+        async with self._aio_lock:
+            await self.async_hard_refresh_codes()
+
     def set_usercode(
         self, code_slot: int, usercode: int | str, name: str | None = None
     ) -> None:
@@ -142,6 +160,14 @@ async def async_set_usercode(
             functools.partial(self.set_usercode, code_slot, usercode, name=name)
         )
 
+    @final
+    async def async_internal_set_usercode(
+        self, code_slot: int, usercode: int | str, name: str | None = None
+    ) -> None:
+        """Set a usercode on a code slot."""
+        async with self._aio_lock:
+            await self.async_set_usercode(code_slot, usercode, name=name)
+
     def clear_usercode(self, code_slot: int) -> None:
         """Clear a usercode on a code slot."""
         raise HomeAssistantError from NotImplementedError()
@@ -150,6 +176,12 @@ async def async_clear_usercode(self, code_slot: int) -> None:
         """Clear a usercode on a code slot."""
         await self.hass.async_add_executor_job(self.clear_usercode, code_slot)
 
+    @final
+    async def async_internal_clear_usercode(self, code_slot: int) -> None:
+        """Clear a usercode on a code slot."""
+        async with self._aio_lock:
+            await self.async_clear_usercode(code_slot)
+
     def get_usercodes(self) -> dict[int, int | str]:
         """
         Get dictionary of code slots and usercodes.
@@ -178,6 +210,22 @@ async def async_get_usercodes(self) -> dict[int, int | str]:
         """
         return await self.hass.async_add_executor_job(self.get_usercodes)
 
+    @final
+    async def async_internal_get_usercodes(self) -> dict[int, int | str]:
+        """
+        Get dictionary of code slots and usercodes.
+
+        Called by data coordinator to get data for code slot sensors.
+
+        Key is code slot, value is usercode, e.g.:
+        {
+            1: '1234',
+            'B': '5678',
+        }
+        """
+        async with self._aio_lock:
+            return await self.async_get_usercodes()
+
     @final
     def call_service(
         self,

tests/_base/test_provider.py

@@ -27,12 +27,12 @@ async def test_base(hass: HomeAssistant):
     with pytest.raises(NotImplementedError):
         lock.domain
     with pytest.raises(NotImplementedError):
-        await lock.async_is_connection_up()
+        await lock.async_internal_is_connection_up()
     with pytest.raises(HomeAssistantError):
-        await lock.async_hard_refresh_codes()
+        await lock.async_internal_hard_refresh_codes()
     with pytest.raises(HomeAssistantError):
-        await lock.async_clear_usercode(1)
+        await lock.async_internal_clear_usercode(1)
     with pytest.raises(HomeAssistantError):
-        await lock.async_set_usercode(1, 1)
+        await lock.async_internal_set_usercode(1, 1)
     with pytest.raises(NotImplementedError):
-        await lock.async_get_usercodes()
+        await lock.async_internal_get_usercodes()

tests/virtual/test_provider.py

@@ -24,18 +24,18 @@ async def test_door_lock(hass: HomeAssistant):
     assert await lock.async_setup() is None
     assert lock.usercode_scan_interval == timedelta(minutes=1)
     assert lock.domain == "virtual"
-    assert await lock.async_is_connection_up()
+    assert await lock.async_internal_is_connection_up()
     assert lock._data == {}
-    await lock.async_hard_refresh_codes()
+    await lock.async_internal_hard_refresh_codes()
     assert lock._data == {}
     # we should not be able to clear a usercode that does not exist
     with pytest.raises(HomeAssistantError):
-        await lock.async_clear_usercode(1)
+        await lock.async_internal_clear_usercode(1)
 
     # we should be able to set a usercode and see it in the data
-    await lock.async_set_usercode(1, 1, "test")
+    await lock.async_internal_set_usercode(1, 1, "test")
     assert lock._data["1"] == {"code": 1, "name": "test"}
-    await lock.async_get_usercodes()
+    await lock.async_internal_get_usercodes()
     assert lock._data["1"] == {"code": 1, "name": "test"}
 
     # if we unload without removing permanently, the data should be saved
@@ -44,9 +44,9 @@ async def test_door_lock(hass: HomeAssistant):
     assert lock._data["1"] == {"code": 1, "name": "test"}
 
     # we can clear a valid usercode
-    await lock.async_set_usercode(2, 2, "test2")
+    await lock.async_internal_set_usercode(2, 2, "test2")
     assert lock._data["2"] == {"code": 2, "name": "test2"}
-    await lock.async_clear_usercode(2)
+    await lock.async_internal_clear_usercode(2)
     assert "2" not in lock._data
 
     # if we unload with removing permanently, the data should be removed