make some more event handlers threaded

Author: d-biehl

robotcode/language_server/common/text_document.py

@@ -162,9 +162,9 @@ async def cache_invalidated(sender) -> None:  # NOSONAR
         ...
 
     async def _invalidate_cache(self) -> None:
-        await self.cache_invalidate(self)
+        create_sub_task(self.cache_invalidate(self))
         self._cache.clear()
-        await self.cache_invalidated(self)
+        create_sub_task(self.cache_invalidated(self))
 
     @_logger.call
     async def invalidate_cache(self) -> None:

robotcode/language_server/robotframework/diagnostics/imports_manager.py

@@ -26,7 +26,7 @@
 )
 
 from ....utils.async_cache import AsyncSimpleLRUCache
-from ....utils.async_tools import Lock, async_tasking_event, create_sub_task
+from ....utils.async_tools import Lock, async_tasking_event, create_sub_task, threaded
 from ....utils.logging import LoggingDescriptor
 from ....utils.path import path_is_relative_to
 from ....utils.uri import Uri
@@ -556,10 +556,12 @@ async def variables_changed(sender, variables: List[LibraryDoc]) -> None:  # NOS
     async def imports_changed(sender, uri: DocumentUri) -> None:  # NOSONAR
         ...
 
+    @threaded()
     async def _do_imports_changed(self, sender: Any, uri: DocumentUri) -> None:  # NOSONAR
         await self.imports_changed(self, uri)
 
     @language_id("robotframework")
+    @threaded()
     async def resource_document_changed(self, sender: Any, document: TextDocument) -> None:
         resource_changed: List[LibraryDoc] = []
 

robotcode/language_server/robotframework/parts/diagnostics.py

@@ -53,6 +53,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
         parent.documents_cache.namespace_invalidated.add(self.namespace_invalidated)
 
     @language_id("robotframework")
+    @threaded()
     @_logger.call
     async def namespace_invalidated(self, sender: Any, namespace: Namespace) -> None:
         if namespace.document is not None:

robotcode/language_server/robotframework/parts/references.py

@@ -15,7 +15,7 @@
 )
 
 from ....utils.async_cache import AsyncSimpleLRUCache
-from ....utils.async_tools import async_event
+from ....utils.async_tools import async_event, threaded
 from ....utils.logging import LoggingDescriptor
 from ....utils.uri import Uri
 from ...common.decorators import language_id
@@ -56,6 +56,7 @@ def __init__(self, parent: RobotLanguageServerProtocol) -> None:
     async def cache_cleared(sender) -> None:  # NOSONAR
         ...
 
+    @threaded()
     async def document_did_change(self, sender: Any, document: TextDocument) -> None:
         await self._keyword_reference_cache.clear()
         await self._variable_reference_cache.clear()

robotcode/utils/async_tools.py

@@ -618,9 +618,11 @@ async def release(self) -> None:
         await super().release()
 
 
-class Lock:
+class NewNewLock:
     def __init__(self) -> None:
         self._lock = threading.Lock()
+        self._owner_thread: Optional[threading.Thread] = None
+        self._owner_task: Optional[asyncio.Task[Any]] = None
 
     def locked(self) -> bool:
         return self._lock.locked()
@@ -630,12 +632,11 @@ def acquire(self, blocking: bool = True, timeout: float = -1) -> bool:
 
     def release(self) -> None:
         self._lock.release()
-        self._owner_thread: Optional[threading.Thread] = None
-        self._owner_task: Optional[asyncio.Task[Any]] = None
+        self._owner_task = None
+        self._owner_thread = None
 
     async def acquire_async(self, blocking: bool = True, timeout: float = -1) -> bool:
         start = time.monotonic()
-
         while not (aquired := self.acquire(blocking=False)):
             if not blocking:
                 return False
@@ -644,23 +645,29 @@ async def acquire_async(self, blocking: bool = True, timeout: float = -1) -> boo
             if timeout > 0 and current > timeout:
                 break
 
-            if current > 30:
+            if current > 30 and self._owner_task is not None:
                 tb = traceback.format_stack(self._owner_task.get_stack()[0]) if self._owner_task is not None else ""
                 warnings.warn(
                     f"locking takes to long {self._owner_thread} {self._owner_task} {tb}",
                 )
 
             await asyncio.sleep(0)
 
+        try:
+            await asyncio.sleep(0)
+        except asyncio.CancelledError:
+            if aquired:
+                self._lock.release()
+                aquired = False
+            raise
+
         self._owner_task = asyncio.current_task()
         self._owner_thread = threading.current_thread()
 
         return aquired
 
     async def release_async(self) -> None:
-        self._lock.release()
-        self._owner_task = None
-        self._owner_thread = None
+        self.release()
 
     def __enter__(self) -> None:
         self.acquire()
@@ -705,7 +712,7 @@ async def __aexit__(
         await self.release()
 
 
-class OldLock:
+class Lock:
     """Threadsafe version of an async Lock."""
 
     def __init__(self) -> None:
@@ -732,7 +739,7 @@ def __repr__(self) -> str:
     async def __inner_lock(self) -> AsyncGenerator[Any, None]:
         b = self._lock.acquire(blocking=False)
         while not b:
-            await asyncio.sleep(0)
+            await asyncio.sleep(0.001)
             b = self._lock.acquire(blocking=False)
         try:
             yield None
@@ -817,9 +824,6 @@ def set_result(w: asyncio.Future[Any], ev: threading.Event) -> None:
 
                         await asyncio.sleep(0.001)
 
-                    # if not done.wait(120):
-                    #     raise TimeoutError("Callback timeout.")
-
 
 class FutureInfo:
     def __init__(self, future: asyncio.Future[Any]) -> None: