Properly handle multiple instances of the same bot

Telegram doesn't allow multiple instances of the same bot to live
together, and previous this commit that behavior resulted in a bunch of
"Error fetching the updates" messages spammed to the bot logs.

This commit properly handles the situation, providing only a nice
message when the thing happens and waiting for the other instances to
shut down in the background. Then, after botogram is reasonably sure
the other instances are down, a message is displayed to the user and
the bot starts working again.

This definitely improves the situation in those cases.

Author: Pietro Albini

botogram/runner/processes.py

@@ -168,20 +168,28 @@ def setup(self, bot, commands):
 
         self.fetcher = updates_module.UpdatesFetcher(bot)
 
-    def loop(self):
-        # This allows to control the process
+    def should_stop(self):
+        """Check if the process should stop"""
         try:
             command = self.commands.get(False)
-
-            # The None command will stop the process
-            if command == "stop":
-                self.stop = True
-                return
         except queue.Empty:
-            pass
+            val = False
+        else:
+            val = command == "stop"
+
+        self.stop = val
+        return val
+
+    def loop(self):
+        # This allows to control the process
+        if self.should_stop():
+            return
 
         try:
             updates, backlog = self.fetcher.fetch()
+        except updates_module.AnotherInstanceRunningError:
+            self.handle_another_instance()
+            return
         except api.APIError as e:
             self.logger.error("An error occured while fetching updates!")
             self.logger.debug("Exception type: %s" % e.__class__.__name__)
@@ -209,6 +217,22 @@ def loop(self):
 
             self.ipc.command("jobs.bulk_put", result)
 
+    def handle_another_instance(self):
+        """Code run when another instance of the bot is running"""
+        # Tell the user what's happening
+        self.logger.error("Another instance of this bot is running!")
+        self.logger.error("Please close any other instance of the bot, and "
+                          "this one will start working again")
+        self.logger.error("If you can't find other instances just revoke the "
+                          "API token")
+
+        # Wait until the other instances are closed
+        result = self.fetcher.block_until_alone(when_stop=self.should_stop)
+
+        if result:
+            self.logger.info("This instance is now the only one. The bot is "
+                             "working again")
+
 
 def _ignore_signal(*__):
     pass

botogram/updates.py

@@ -17,6 +17,14 @@ class FetchError(api.APIError):
     pass
 
 
+class AnotherInstanceRunningError(FetchError):
+    """Another instance of your bot is running somewhere else"""
+
+    def __init__(self):
+        Exception.__init__(self, "Request terminated because of another long "
+                           "pooling or webhook active")
+
+
 class UpdatesFetcher:
     """Logic for fetching updates"""
 
@@ -30,16 +38,25 @@ def __init__(self, bot):
         if bot.process_backlog:
             self._backlog_processed = True
 
-    def fetch(self, timeout=1):
-        """Fetch the latest updates"""
+    def _fetch_updates(self, timeout):
+        """Low level function to just fetch updates from Telegram"""
         try:
-            updates = self._bot.api.call("getUpdates", {
+            return self._bot.api.call("getUpdates", {
                 "offset": self._last_id + 1,
                 "timeout": timeout,
             }, expect=objects.Updates)
+        except api.APIError as e:
+            # Raise a specific exception if another instance is running
+            if e.error_code == 409 and "conflict" in e.description.lower():
+                raise AnotherInstanceRunningError()
+            raise
         except ValueError:
             raise FetchError("Got an invalid response from Telegram!")
 
+    def fetch(self, timeout=1):
+        """Fetch the latest updates"""
+        updates = self._fetch_updates(timeout)
+
         # If there are no updates just ignore this block
         try:
             self._last_id = updates[-1].update_id
@@ -100,6 +117,39 @@ def fetch(self, timeout=1):
         # The first is the updates to process, the second the backlog
         return updates[to_check:], updates[:to_check]
 
+    def block_until_alone(self, treshold=4, check_timeout=1, when_stop=None):
+        """Returns when this one is the only instance of the bot"""
+        checks_count = 0
+
+        while checks_count < treshold:
+            # This provides an artificial end to the blocking
+            if when_stop():
+                return False
+
+            try:
+                updates = self._fetch_updates(check_timeout)
+            except AnotherInstanceRunningError:
+                # Reset the count
+                checks_count = 0
+                continue
+
+            # Update the last_id
+            try:
+                self._last_id = updates[-1].update_id
+            except IndexError:
+                pass
+
+            # Don't count requests with new updates, since they don't tell if
+            # another instance is running, they only make noise
+            if updates:
+                continue
+
+            # Increment the count every time a request succedes, so the whole
+            # function exits when checks_needed is reached
+            checks_count += 1
+
+        return True
+
     @property
     def backlog_processed(self):
         return self._backlog_processed

docs/changelog.rst

@@ -44,6 +44,7 @@ New features
 * Added new attribute :py:attr:`botogram.Sticker.emoji`
 * Every method which sends something to a chat now returns the sent
   :py:class:`~botogram.Message`
+* Multiple instances of the same bot are now properly handled (as errors)
 
 Changes
 -------