No events during on_join(..) (#36)

* No events during on_join(..)

* Update README.md, 0 no longer waits

Author: joente

README.md

@@ -485,7 +485,7 @@ This is an async method and usually the best method to perform
 some ThingsDB queries (if required).
 
 Unless the `wait` argument to the Room.join(..) function is explicitly
-set to None, the first call to this method will finish before the
+set to `0` or `None`, the first call to this method will finish before the
 call to `Room.join()` is returned.
 
 ### on_leave(self) -> None:
@@ -514,7 +514,7 @@ Property | Description
 ### join
 
 ```python
-Room().join(client: Client, wait: Optional[float] = 60) -> None
+Room().join(client: Client, wait: Optional[float] = 60.0) -> None
 ```
 
 Joins the room.
@@ -524,7 +524,7 @@ Joins the room.
         ThingsDB client instance.
 - wait *(float)*:
     Max time (in seconds) to wait for the first `on_join` call.
-    If wait is set to None, the join method will not wait for
+    If wait is set to `0` or `None`, the join method will not wait for
     the first `on_join` call to happen.
 
 

thingsdb/client/client.py

@@ -563,7 +563,9 @@ async def _on_room(self, room_id, pkg):
                     f'Got an event (tp:{pkg.tp}) for room Id {room_id} but '
                     f'the room is not known by the ThingsDB client')
             else:
-                room._on_event(pkg)
+                task = room._on_event(pkg)
+                if isinstance(task, asyncio.Task):
+                    await task
 
     def _on_event(self, pkg):
         if pkg.tp == Proto.ON_NODE_STATUS:

thingsdb/room/roombase.py

@@ -36,7 +36,7 @@ def __init__(
         self._client = None
         self._id = room
         self._scope = scope
-        self._wait_join = None
+        self._wait_join = False
 
     @property
     def id(self):
@@ -50,16 +50,16 @@ def scope(self):
     def client(self):
         return self._client
 
-    async def join(self, client: Client, wait: Optional[float] = 60):
+    async def join(self, client: Client, wait: Optional[float] = 60.0):
         """Join a room.
 
         Args:
             client (thingsdb.client.Client):
                 ThingsDB client instance.
             wait (float):
                 Max time (in seconds) to wait for the first `on_join` call.
-                If wait is set to None, the join method will not wait for
-                the first `on_join` call to happen.
+                If wait is set to `0` or `None`, the join method will not
+                wait for the first `on_join` call to happen.
         """
         # Although ThingsDB guarantees to return the response on the join
         # request before the "on_join" event is being transmitted, the asyncio
@@ -100,10 +100,10 @@ async def join(self, client: Client, wait: Optional[float] = 60):
 
             client._rooms[self._id] = self
             self.on_init()
-            if wait is not None:
+            if wait:
                 self._wait_join = asyncio.Future()
 
-        if wait is not None:
+        if wait:
             # wait for the first join to finish
             await asyncio.wait_for(self._wait_join, wait)
 
@@ -136,8 +136,8 @@ def emit(self, event: str, *args) -> asyncio.Future:
         """
         return self._client._emit(self._id, event, *args, scope=self._scope)
 
-    def _on_event(self, pkg):
-        self.__class__._ROOM_EVENT_MAP[pkg.tp](self, pkg.data)
+    def _on_event(self, pkg) -> Optional[asyncio.Task]:
+        return self.__class__._ROOM_EVENT_MAP[pkg.tp](self, pkg.data)
 
     @abc.abstractmethod
     def on_init(self) -> None:
@@ -169,10 +169,19 @@ async def _on_first_join(self):
             fut.set_result(None)
 
     def _on_join(self, _data):
-        loop = self.client.get_event_loop()
         if self._wait_join:
-            asyncio.ensure_future(self._on_first_join(), loop=loop)
+            # Future, the first join. Return a task so the room lock is kept
+            # until the on_first_join is finished
+            return asyncio.create_task(self._on_first_join())
+        elif self._wait_join is None:
+            # Initially a wait was set, do not handle (new) events until the
+            # join is (again) finished
+            return asyncio.create_task(self.on_join())
         else:
+            # User has decided not to wait for the join. Thus we can asume that
+            # event handlers do not depend on the on_join to be finished
+            assert self._wait_join is False
+            loop = self.client.get_event_loop()
             asyncio.ensure_future(self.on_join(), loop=loop)
 
     def _on_stop(self, func):

thingsdb/version.py

@@ -1 +1 @@
-__version__ = '1.0.2'
+__version__ = '1.0.3'