fix: 🐛 Blocking Call Warnungen vollständig behoben durch Einführung von S3ClientWrapper für S3-Operationen in einem dedizierten Worker-Thread

Author: karlspace

CHANGELOG.md

@@ -5,11 +5,23 @@ Alle wichtigen Änderungen an diesem Projekt werden in dieser Datei dokumentiert
 Das Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.0.0/),
 und dieses Projekt folgt [Semantic Versioning](https://semver.org/lang/de/).
 
+## [0.1.5] - 2026-01-13
+
+### 🐛 Fixed
+
+- **Blocking Call Warnungen vollständig behoben**
+  - Neuer `S3ClientWrapper` führt alle S3-Operationen in dediziertem Worker-Thread aus
+  - Behebt alle `Detected blocking call` Warnungen (`listdir`, `open`, `load_verify_locations`)
+  - Vorherige Lösung (0.1.4) war unzureichend, da jede AioSession eigenen Loader-Cache hat
+  - Worker-Thread mit eigenem Event-Loop vermeidet Blockierung des Home Assistant Event-Loops
+
+---
+
 ## [0.1.4] - 2026-01-12
 
 ### 🐛 Fixed
 
-- **Blocking Call Warnungen behoben**
+- **Blocking Call Warnungen behoben** (teilweise - siehe 0.1.5)
   - S3-Client-Erstellung und Validierung erfolgt nun in einem Executor-Thread
   - Behebt `Detected blocking call to listdir` und ähnliche Warnungen in Home Assistant
   - Betrifft botocore's synchrone I/O-Operationen (listdir, Datei-Lese, SSL-Zertifikat-Laden)

custom_components/bauergroup_s3compatiblebackup/__init__.py

@@ -4,9 +4,9 @@
 
 import asyncio
 import logging
-from typing import cast
+from threading import Thread
+from typing import Any, cast
 
-from aiobotocore.client import AioBaseClient as BotoClient
 from aiobotocore.session import AioSession
 from botocore.exceptions import ClientError, ConnectionError, ParamValidationError
 
@@ -25,38 +25,147 @@
     DOMAIN,
 )
 
-type S3CompatibleConfigEntry = ConfigEntry[BotoClient]
-
-
 _LOGGER = logging.getLogger(__name__)
 
 
-def _verify_s3_credentials(
-    endpoint_url: str | None,
-    access_key: str,
-    secret_key: str,
-    region: str,
-    bucket: str,
-) -> None:
-    """Verify S3 credentials in executor to avoid blocking the event loop.
+class S3ClientWrapper:
+    """Wrapper for S3 client that runs all operations in a dedicated worker thread.
 
-    This creates a temporary client in a separate thread with its own event loop.
-    All blocking operations (botocore data loading, SSL certificate loading)
-    happen here, warming the OS-level caches for subsequent client creation.
+    This avoids blocking the main Home Assistant event loop with botocore's
+    synchronous I/O operations (listdir, file reads, SSL certificate loading).
+    All S3 operations are dispatched to a worker thread with its own event loop.
     """
 
-    async def _verify() -> None:
+    def __init__(
+        self,
+        endpoint_url: str | None,
+        access_key: str,
+        secret_key: str,
+        region: str,
+        bucket: str,
+    ) -> None:
+        """Initialize the wrapper and start the worker thread."""
+        self._endpoint_url = endpoint_url
+        self._access_key = access_key
+        self._secret_key = secret_key
+        self._region = region
+        self._bucket = bucket
+        self._client: Any = None
+        self._loop: asyncio.AbstractEventLoop | None = None
+        self._thread: Thread | None = None
+        self._started = False
+
+    def _run_worker_loop(self) -> None:
+        """Run the worker event loop in a dedicated thread."""
+        self._loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(self._loop)
+        self._loop.run_forever()
+
+    async def _create_client(self) -> None:
+        """Create the S3 client (runs in worker thread)."""
         session = AioSession()
-        async with session.create_client(
+        # pylint: disable-next=unnecessary-dunder-call
+        self._client = await session.create_client(
             "s3",
-            endpoint_url=endpoint_url,
-            aws_secret_access_key=secret_key,
-            aws_access_key_id=access_key,
-            region_name=region,
-        ) as client:
-            await client.head_bucket(Bucket=bucket)
+            endpoint_url=self._endpoint_url,
+            aws_secret_access_key=self._secret_key,
+            aws_access_key_id=self._access_key,
+            region_name=self._region,
+        ).__aenter__()
+        # Verify credentials and warm SSL context
+        await self._client.head_bucket(Bucket=self._bucket)
+
+    async def _close_client(self) -> None:
+        """Close the S3 client (runs in worker thread)."""
+        if self._client:
+            await self._client.__aexit__(None, None, None)
+            self._client = None
+
+    def start(self) -> None:
+        """Start the worker thread and create the client.
+
+        This method blocks until the client is ready.
+        Should be called from an executor via hass.async_add_executor_job.
+        """
+        if self._started:
+            return
+
+        # Start worker thread
+        self._thread = Thread(target=self._run_worker_loop, daemon=True)
+        self._thread.start()
+
+        # Wait for loop to be ready
+        while self._loop is None:
+            pass
+
+        # Create client in worker thread
+        future = asyncio.run_coroutine_threadsafe(self._create_client(), self._loop)
+        future.result()  # Block until client is created
+        self._started = True
+
+    def stop(self) -> None:
+        """Stop the worker thread and close the client.
+
+        Should be called from an executor via hass.async_add_executor_job.
+        """
+        if not self._started or self._loop is None:
+            return
+
+        # Close client in worker thread
+        future = asyncio.run_coroutine_threadsafe(self._close_client(), self._loop)
+        future.result()
+
+        # Stop the loop
+        self._loop.call_soon_threadsafe(self._loop.stop)
+        if self._thread:
+            self._thread.join(timeout=5)
+        self._started = False
+
+    async def _dispatch[T](self, coro: Any) -> T:
+        """Dispatch a coroutine to the worker thread and await its result."""
+        if self._loop is None:
+            raise RuntimeError("Worker loop not started")
+        future = asyncio.run_coroutine_threadsafe(coro, self._loop)
+        return await asyncio.wrap_future(future)
 
-    asyncio.run(_verify())
+    async def head_bucket(self, **kwargs: Any) -> dict[str, Any]:
+        """Check if a bucket exists and is accessible."""
+        return await self._dispatch(self._client.head_bucket(**kwargs))
+
+    async def list_objects_v2(self, **kwargs: Any) -> dict[str, Any]:
+        """List objects in a bucket."""
+        return await self._dispatch(self._client.list_objects_v2(**kwargs))
+
+    async def get_object(self, **kwargs: Any) -> dict[str, Any]:
+        """Get an object from a bucket."""
+        return await self._dispatch(self._client.get_object(**kwargs))
+
+    async def put_object(self, **kwargs: Any) -> dict[str, Any]:
+        """Put an object into a bucket."""
+        return await self._dispatch(self._client.put_object(**kwargs))
+
+    async def delete_object(self, **kwargs: Any) -> dict[str, Any]:
+        """Delete an object from a bucket."""
+        return await self._dispatch(self._client.delete_object(**kwargs))
+
+    async def create_multipart_upload(self, **kwargs: Any) -> dict[str, Any]:
+        """Initiate a multipart upload."""
+        return await self._dispatch(self._client.create_multipart_upload(**kwargs))
+
+    async def upload_part(self, **kwargs: Any) -> dict[str, Any]:
+        """Upload a part in a multipart upload."""
+        return await self._dispatch(self._client.upload_part(**kwargs))
+
+    async def complete_multipart_upload(self, **kwargs: Any) -> dict[str, Any]:
+        """Complete a multipart upload."""
+        return await self._dispatch(self._client.complete_multipart_upload(**kwargs))
+
+    async def abort_multipart_upload(self, **kwargs: Any) -> dict[str, Any]:
+        """Abort a multipart upload."""
+        return await self._dispatch(self._client.abort_multipart_upload(**kwargs))
+
+
+type S3CompatibleConfigEntry = ConfigEntry[S3ClientWrapper]
 
 
 async def async_setup_entry(hass: HomeAssistant, entry: S3CompatibleConfigEntry) -> bool:
@@ -65,29 +174,18 @@ async def async_setup_entry(hass: HomeAssistant, entry: S3CompatibleConfigEntry)
     data = cast(dict, entry.data)
     region = data.get(CONF_REGION, DEFAULT_REGION)
 
+    # Create wrapper that will run S3 client in dedicated worker thread
+    wrapper = S3ClientWrapper(
+        endpoint_url=data.get(CONF_ENDPOINT_URL),
+        access_key=data[CONF_ACCESS_KEY_ID],
+        secret_key=data[CONF_SECRET_ACCESS_KEY],
+        region=region,
+        bucket=data[CONF_BUCKET],
+    )
+
     try:
-        # Verify credentials in executor to avoid blocking the event loop
-        # with botocore's synchronous I/O operations (listdir, file reads, SSL loading)
-        await hass.async_add_executor_job(
-            _verify_s3_credentials,
-            data.get(CONF_ENDPOINT_URL),
-            data[CONF_ACCESS_KEY_ID],
-            data[CONF_SECRET_ACCESS_KEY],
-            region,
-            data[CONF_BUCKET],
-        )
-
-        # Create the actual client for runtime use
-        # OS-level caches are now warm from the verification step
-        session = AioSession()
-        # pylint: disable-next=unnecessary-dunder-call
-        client = await session.create_client(
-            "s3",
-            endpoint_url=data.get(CONF_ENDPOINT_URL),
-            aws_secret_access_key=data[CONF_SECRET_ACCESS_KEY],
-            aws_access_key_id=data[CONF_ACCESS_KEY_ID],
-            region_name=region,
-        ).__aenter__()
+        # Start wrapper in executor - all blocking I/O happens in worker thread
+        await hass.async_add_executor_job(wrapper.start)
     except ClientError as err:
         raise ConfigEntryAuthFailed(
             translation_domain=DOMAIN,
@@ -111,7 +209,7 @@ async def async_setup_entry(hass: HomeAssistant, entry: S3CompatibleConfigEntry)
             translation_key="cannot_connect",
         ) from err
 
-    entry.runtime_data = client
+    entry.runtime_data = wrapper
 
     def notify_backup_listeners() -> None:
         for listener in hass.data.get(DATA_BACKUP_AGENT_LISTENERS, []):
@@ -124,6 +222,6 @@ def notify_backup_listeners() -> None:
 
 async def async_unload_entry(hass: HomeAssistant, entry: S3CompatibleConfigEntry) -> bool:
     """Unload a config entry."""
-    client = entry.runtime_data
-    await client.__aexit__(None, None, None)
+    wrapper = entry.runtime_data
+    await hass.async_add_executor_job(wrapper.stop)
     return True

custom_components/bauergroup_s3compatiblebackup/backup.py

@@ -18,7 +18,7 @@
 )
 from homeassistant.core import HomeAssistant, callback
 
-from . import S3CompatibleConfigEntry
+from . import S3ClientWrapper, S3CompatibleConfigEntry
 from .const import (
     BACKUP_FOLDER,
     CONF_BUCKET,
@@ -100,7 +100,7 @@ class S3CompatibleBackupAgent(BackupAgent):
     def __init__(self, hass: HomeAssistant, entry: S3CompatibleConfigEntry) -> None:
         """Initialize the S3 backup agent."""
         super().__init__()
-        self._client = entry.runtime_data
+        self._client: S3ClientWrapper = entry.runtime_data
         self._bucket: str = entry.data[CONF_BUCKET]
         self._prefix: str = self._build_prefix(entry.data.get(CONF_PREFIX, DEFAULT_PREFIX))
         self.name = entry.title

custom_components/bauergroup_s3compatiblebackup/manifest.json

@@ -16,5 +16,5 @@
   "requirements": [
     "aiobotocore>=2.6.0,<3.0.0"
   ],
-  "version": "0.1.4"
+  "version": "0.1.5"
 }