Merge branch 'gonzobot' into gonzobot+horoscope-fix

Author: linuxdaemon

.travis.yml

@@ -7,12 +7,12 @@ python:
 
 install:
   - "sudo apt-get update -q"
-  - "sudo apt-get install -y python3-lxml"
+  - "sudo apt-get install -y python3-lxml libenchant-dev"
   - "pip install -r ./travis/requirements.txt"
 
 script:
   - "python ./travis/test_json.py"
-  - "git diff --diff-filter=d --name-only ${TRAVIS_COMMIT_RANGE} | xargs pylint --rcfile=travis/pylintrc"
+  - "git diff --diff-filter=d --name-only ${TRAVIS_COMMIT_RANGE} | grep -i '\\.py$' | xargs -r pylint --rcfile=travis/pylintrc"
   - "py.test . -v --cov . --cov-report term-missing"
 
 after_success:

README.md

@@ -5,10 +5,10 @@ CloudBot is a simple, fast, expandable open-source Python IRC Bot!
 ## Getting CloudBot
 
 There are currently four different branches of this repository, each with a different level of stability:
- - **gonzobot** *(stable)*: This branch contains everything in the **master** branch plus additional plugins added for Snoonet IRC.
+ - **gonzobot** *(stable)*: This branch contains everything in the **master** branch plus additional plugins added for Snoonet IRC. This branch is the currently maintained branch which will also contain many fixes for various bugs from the master branch.
  - **gonzobot-dev** *(unstable)*: This branch is based off of the **gonzobot** branch and includes new plugins that are not fully tested.
- - **master** *(stable)*: This branch contains stable, tested code. This is the branch you should be using if you just want to run your own CloudBot! This is also the branch that EDI on Snoonet uses.
- - **python3.4** *(unstable)*: This branch is where where test and develop new features. If you would like to help develop CloudBot, you can use this branch.
+ - **master** *(stable (old))*: This branch contains stable, tested code. This branch is based directly on the upstream master branch and is not currently maintained.
+ - **python3.4** *(unstable (old))*: This is the outdated testing branch from the upstream repo.
 
 New releases will be pushed from **python3.4** to **master** whenever we have a stable version to release. These changes will be merged into **gonzobot** then deployed. This should happen on a fairly regular basis, so you'll never be too far behind the latest improvements.
 

cloudbot/__init__.py

@@ -12,7 +12,7 @@
 
 __version__ = "1.0.9"
 
-__all__ = ["util", "bot", "connection", "config", "permissions", "plugin", "event", "hook", "log_dir"]
+__all__ = ["clients", "util", "bot", "client", "config", "event", "hook", "permissions", "plugin", "reloader", "logging_dir"]
 
 
 def _setup():

cloudbot/__main__.py

@@ -3,8 +3,8 @@
 import signal
 import sys
 import time
+
 # store the original working directory, for use when restarting
-from functools import partial
 
 original_wd = os.path.realpath(".")
 
@@ -47,9 +47,7 @@ def exit_gracefully(signum, frame):
             # we are currently in the process of restarting
             stopped_while_restarting = True
         else:
-            _bot.loop.call_soon_threadsafe(
-                partial(async_util.wrap_future, _bot.stop("Killed (Received SIGINT {})".format(signum)), loop=_bot.loop)
-            )
+            async_util.run_coroutine_threadsafe(_bot.stop("Killed (Received SIGINT {})".format(signum)), _bot.loop)
 
         logger.warning("Bot received Signal Interrupt ({})".format(signum))
 

cloudbot/bot.py

@@ -20,7 +20,7 @@
 from cloudbot.hook import Action
 from cloudbot.plugin import PluginManager
 from cloudbot.reloader import PluginReloader, ConfigReloader
-from cloudbot.util import database, formatting
+from cloudbot.util import database, formatting, async_util
 
 try:
     from cloudbot.web.main import WebInterface
@@ -65,7 +65,7 @@ def __init__(self, loop=asyncio.get_event_loop()):
         self.start_time = time.time()
         self.running = True
         # future which will be called when the bot stopsIf you
-        self.stopped_future = asyncio.Future(loop=self.loop)
+        self.stopped_future = async_util.create_future(self.loop)
 
         # stores each bot server connection
         self.connections = {}
@@ -221,7 +221,7 @@ def _init_routine(self):
         self.observer.start()
 
         # Connect to servers
-        yield from asyncio.gather(*[conn.connect() for conn in self.connections.values()], loop=self.loop)
+        yield from asyncio.gather(*[conn.try_connect() for conn in self.connections.values()], loop=self.loop)
 
         # Activate web interface.
         if self.config.get("web", {}).get("enabled", False) and web_installed:

cloudbot/client.py

@@ -1,6 +1,7 @@
 import asyncio
-import logging
 import collections
+import logging
+import random
 
 from cloudbot.permissions import PermissionManager
 
@@ -59,7 +60,20 @@ def describe_server(self):
         raise NotImplementedError
 
     @asyncio.coroutine
-    def connect(self):
+    def try_connect(self):
+        timeout = 30
+        while True:
+            try:
+                yield from self.connect(timeout)
+            except Exception:
+                logger.exception("[%s] Error occurred while connecting.")
+            else:
+                break
+
+            yield from asyncio.sleep(random.randrange(timeout))
+
+    @asyncio.coroutine
+    def connect(self, timeout=None):
         """
         Connects to the server, or reconnects if already connected.
         """
@@ -85,6 +99,14 @@ def message(self, target, *text):
         """
         raise NotImplementedError
 
+    def admin_log(self, text, console=True):
+        """
+        Log a message to the configured admin channel
+        :type text: str
+        :type console: bool
+        """
+        raise NotImplementedError
+
     def action(self, target, text):
         """
         Sends an action (or /me) to the given target channel

cloudbot/clients/irc.py

@@ -1,8 +1,10 @@
 import asyncio
 import logging
+import random
 import re
 import ssl
 from _ssl import PROTOCOL_SSLv23
+from functools import partial
 from ssl import SSLContext
 
 from cloudbot.client import Client
@@ -106,7 +108,20 @@ def describe_server(self):
             return "{}:{}".format(self.server, self.port)
 
     @asyncio.coroutine
-    def connect(self):
+    def try_connect(self):
+        timeout = self.config["connection"].get("timeout", 30)
+        while True:
+            try:
+                yield from self.connect(timeout)
+            except (asyncio.TimeoutError, OSError):
+                logger.exception("[%s] Error occurred while connecting", self.name)
+            else:
+                break
+
+            yield from asyncio.sleep(random.randrange(timeout))
+
+    @asyncio.coroutine
+    def connect(self, timeout=None):
         """
         Connects to the IRC server, or reconnects if already connected.
         """
@@ -125,8 +140,15 @@ def connect(self):
         optional_params = {}
         if self.local_bind:
             optional_params["local_addr"] = self.local_bind
-        self._transport, self._protocol = yield from self.loop.create_connection(
-            lambda: _IrcProtocol(self), host=self.server, port=self.port, ssl=self.ssl_context, **optional_params)
+
+        coro = self.loop.create_connection(
+            partial(_IrcProtocol, self), host=self.server, port=self.port, ssl=self.ssl_context, **optional_params
+        )
+
+        if timeout is not None:
+            coro = asyncio.wait_for(coro, timeout)
+
+        self._transport, self._protocol = yield from coro
 
         tasks = [
             self.bot.plugin_manager.launch(hook, Event(bot=self.bot, conn=self, hook=hook))
@@ -158,6 +180,14 @@ def message(self, target, *messages):
             text = "".join(text.splitlines())
             self.cmd("PRIVMSG", target, text)
 
+    def admin_log(self, text, console=True):
+        log_chan = self.config.get("log_channel")
+        if log_chan:
+            self.message(log_chan, text)
+
+        if console:
+            logger.info("[%s|admin] %s", self.name, text)
+
     def action(self, target, text):
         text = "".join(text.splitlines())
         self.ctcp(target, "ACTION", text)
@@ -263,7 +293,7 @@ def __init__(self, conn):
         self._transport = None
 
         # Future that waits until we are connected
-        self._connected_future = asyncio.Future(loop=self.loop)
+        self._connected_future = async_util.create_future(self.loop)
 
     def connection_made(self, transport):
         self._transport = transport
@@ -275,7 +305,7 @@ def connection_made(self, transport):
     def connection_lost(self, exc):
         self._connected = False
         # create a new connected_future for when we are connected.
-        self._connected_future = asyncio.Future(loop=self.loop)
+        self._connected_future = async_util.create_future(self.loop)
         if exc is None:
             # we've been closed intentionally, so don't reconnect
             return
@@ -285,7 +315,7 @@ def connection_lost(self, exc):
     def eof_received(self):
         self._connected = False
         # create a new connected_future for when we are connected.
-        self._connected_future = asyncio.Future(loop=self.loop)
+        self._connected_future = async_util.create_future(self.loop)
         logger.info("[{}] EOF received.".format(self.conn.name))
         async_util.wrap_future(self.conn.connect(), loop=self.loop)
         return True

cloudbot/config.py

@@ -3,11 +3,12 @@
 import os
 import sys
 import time
+from collections import OrderedDict
 
 logger = logging.getLogger("cloudbot")
 
 
-class Config(dict):
+class Config(OrderedDict):
     """
     :type filename: str
     :type path: str
@@ -41,8 +42,10 @@ def load_config(self):
             sys.exit()
 
         with open(self.path) as f:
-            self.update(json.load(f))
-            logger.debug("Config loaded from file.")
+            data = json.load(f, object_pairs_hook=OrderedDict)
+
+        self.update(data)
+        logger.debug("Config loaded from file.")
 
         # reload permissions
         if self.bot.connections:
@@ -51,5 +54,7 @@ def load_config(self):
 
     def save_config(self):
         """saves the contents of the config dict to the config file"""
-        json.dump(self, open(self.path, 'w'), sort_keys=True, indent=4)
+        with open(self.path, 'w') as f:
+            json.dump(self, f, indent=4)
+
         logger.info("Config saved to file.")

cloudbot/event.py

@@ -2,11 +2,10 @@
 import concurrent.futures
 import enum
 import logging
+import sys
 import warnings
 from functools import partial
 
-import sys
-
 from cloudbot.util.parsers.irc import Message
 
 logger = logging.getLogger("cloudbot")
@@ -154,7 +153,7 @@ def prepare(self):
             raise ValueError("event.hook is required to prepare an event")
 
         if "db" in self.hook.required_args:
-            #logger.debug("Opening database session for {}:threaded=False".format(self.hook.description))
+            # logger.debug("Opening database session for {}:threaded=False".format(self.hook.description))
 
             # we're running a coroutine hook with a db, so initialise an executor pool
             self.db_executor = concurrent.futures.ThreadPoolExecutor(1)
@@ -175,7 +174,7 @@ def prepare_threaded(self):
             raise ValueError("event.hook is required to prepare an event")
 
         if "db" in self.hook.required_args:
-            #logger.debug("Opening database session for {}:threaded=True".format(self.hook.description))
+            # logger.debug("Opening database session for {}:threaded=True".format(self.hook.description))
 
             self.db = self.bot.db_session()
 
@@ -193,7 +192,7 @@ def close(self):
             raise ValueError("event.hook is required to close an event")
 
         if self.db is not None:
-            #logger.debug("Closing database session for {}:threaded=False".format(self.hook.description))
+            # logger.debug("Closing database session for {}:threaded=False".format(self.hook.description))
             # be sure the close the database in the database executor, as it is only accessable in that one thread
             yield from self.async_call(self.db.close)
             self.db = None
@@ -210,7 +209,7 @@ def close_threaded(self):
         if self.hook is None:
             raise ValueError("event.hook is required to close an event")
         if self.db is not None:
-            #logger.debug("Closing database session for {}:threaded=True".format(self.hook.description))
+            # logger.debug("Closing database session for {}:threaded=True".format(self.hook.description))
             self.db.close()
             self.db = None
 
@@ -241,7 +240,20 @@ def message(self, message, target=None):
             if self.chan is None:
                 raise ValueError("Target must be specified when chan is not assigned")
             target = self.chan
-        self.conn.message( target, message)
+        self.conn.message(target, message)
+
+    def admin_log(self, message, broadcast=False):
+        """Log a message in the current connections admin log
+        :type message: str
+        :type broadcast: bool
+        :param message: The message to log
+        :param broadcast: Should this be broadcast to all connections
+        """
+        conns = [self.conn] if not broadcast else self.bot.connections.values()
+
+        for conn in conns:
+            if conn and conn.connected:
+                conn.admin_log(message, console=not broadcast)
 
     def reply(self, *messages, target=None):
         """sends a message to the current channel/user with a prefix

cloudbot/plugin.py

@@ -533,15 +533,26 @@ def _sieve(self, sieve, event, hook):
         else:
             coro = sieve.function(self.bot, event, hook)
 
+        result, error = None, None
         task = async_util.wrap_future(coro)
         sieve.plugin.tasks.append(task)
         try:
             result = yield from task
         except Exception:
             logger.exception("Error running sieve {} on {}:".format(sieve.description, hook.description))
-            result = None
+            error = sys.exc_info()
 
         sieve.plugin.tasks.remove(task)
+
+        post_event = partial(
+            PostHookEvent, launched_hook=sieve, launched_event=event, bot=event.bot,
+            conn=event.conn, result=result, error=error
+        )
+        for post_hook in self.hook_hooks["post"]:
+            success, res = yield from self.internal_launch(post_hook, post_event(hook=post_hook))
+            if success and res is False:
+                break
+
         return result
 
     @asyncio.coroutine
@@ -586,7 +597,7 @@ def launch(self, hook, event):
                     self._hook_waiting_queues[key] = queue
                 assert isinstance(queue, asyncio.Queue)
                 # create a future to represent this task
-                future = asyncio.Future()
+                future = async_util.create_future(self.bot.loop)
                 queue.put_nowait(future)
                 # wait until the last task is completed
                 yield from future