Fix locking issue and optimize a bit

pepubot/__main__.py

@@ -2,13 +2,11 @@
 import asyncio
 import logging
 import sys
-from typing import Any, Mapping, Sequence
-
-import slack
+from typing import Any, Sequence
 
+from . import slack
 from .runner import PePuRunner
 from .settings import initialize_settings
-from .slack import get_rtm_client
 
 LOG = logging.getLogger(__name__)
 
@@ -30,24 +28,19 @@ def parse_args(argv: Sequence[str]) -> Any:
 
 def run_pepubot() -> None:
     LOG.info('Initializing the Slack RTM client')
-    slack_rtm_client = get_rtm_client()
+    slack_rtm_client = slack.get_rtm_client()
+
+    LOG.info('Creating PePuRunner with a Slack Web client')
+    slack_web_client = slack.get_web_client()
+    pepu_runner = PePuRunner(slack_web_client)
 
     LOG.info('Binging our event handler')
-    slack_rtm_client.on(event='message', callback=handle_new_message)
+    slack_rtm_client.on(event='message', callback=pepu_runner.feed_message)
 
     LOG.info('Starting the Slack RTM session in an event loop')
     loop = asyncio.get_event_loop()
     loop.run_until_complete(slack_rtm_client.start())
 
 
-async def handle_new_message(
-        *,
-        data: Mapping[str, Any],
-        web_client: slack.WebClient,
-        **kwargs: object,
-) -> None:
-    await PePuRunner(web_client).feed_message(data)
-
-
 if __name__ == '__main__':
     main()

pepubot/runner.py

@@ -23,13 +23,18 @@ class PePuState(Enum):
 class PePuRunner:
     def __init__(self, slack_client: slack.WebClient) -> None:
         self.slack = slack_client
+        self._state_loaded: bool = False
         self.state: PePuState = PePuState.not_started
         self.start_message: Optional[MessageInfo] = None
         self.round_participants: List[str] = []
         self._lock = asyncio.Lock()
 
-    async def feed_message(self, event_data: Mapping[str, Any]) -> None:
-        message = Message.from_message_event(event_data)
+    async def feed_message(
+            self,
+            data: Mapping[str, Any],
+            **kwargs: object,
+    ) -> None:
+        message = Message.from_message_event(data)
         if not message:
             return
 
@@ -266,6 +271,9 @@ async def dump_lottery_box(self, message: Message) -> None:
                 channel=message.channel, text=text)
 
     async def _load(self) -> None:
+        if self._state_loaded:
+            return
+
         storage = get_default_storage()
 
         async with self._lock:
@@ -281,6 +289,8 @@ async def _load(self) -> None:
 
         self.round_participants = (participants or '').splitlines()
 
+        self._state_loaded = True
+
     async def _save(self) -> None:
         storage = get_default_storage()
         await storage.store_item('runner_state', self.state.value)