Merge branch 'gonzobot' into gonzobot+pager

Author: linuxdaemon

cloudbot/__main__.py

@@ -6,6 +6,10 @@
 import signal
 
 # store the original working directory, for use when restarting
+from functools import partial
+
+from cloudbot.util import async_util
+
 original_wd = os.path.realpath(".")
 
 # set up environment - we need to make sure we are in the install directory
@@ -47,9 +51,10 @@ def exit_gracefully(signum, frame):
             stopped_while_restarting = True
         else:
             _bot.loop.call_soon_threadsafe(
-                lambda: asyncio.async(_bot.stop("Killed (Received SIGINT {})".format(signum)), loop=_bot.loop))
+                partial(async_util.wrap_future, _bot.stop("Killed (Received SIGINT {})".format(signum)), loop=_bot.loop)
+            )
 
-        logger.warn("Bot received Signal Interrupt ({})".format(signum))
+        logger.warning("Bot received Signal Interrupt ({})".format(signum))
 
         # restore the original handler so if they do it again it triggers
         signal.signal(signal.SIGINT, original_sigint)

cloudbot/client.py

@@ -122,6 +122,14 @@ def part(self, channel):
         """
         raise NotImplementedError
 
+    def is_nick_valid(self, nick):
+        """
+        Determines if a nick is valid for this connection
+        :param nick: The nick to check
+        :return: True if it is valid, otherwise false
+        """
+        raise NotImplementedError
+
     @property
     def connected(self):
         raise NotImplementedError

cloudbot/clients/irc.py

@@ -6,7 +6,8 @@
 from ssl import SSLContext
 
 from cloudbot.client import Client
-from cloudbot.event import Event, EventType
+from cloudbot.event import Event, EventType, IrcOutEvent
+from cloudbot.util import async_util
 
 logger = logging.getLogger("cloudbot")
 
@@ -15,11 +16,15 @@
 irc_netmask_re = re.compile(r"([^!@]*)!([^@]*)@(.*)")
 irc_param_re = re.compile(r"(?:^|(?<= ))(:.*|[^ ]+)")
 
+irc_nick_re = re.compile(r'[A-Za-z0-9^{\}\[\]\-`_|\\]+')
+
 irc_bad_chars = ''.join([chr(x) for x in list(range(0, 1)) + list(range(4, 32)) + list(range(127, 160))])
 irc_clean_re = re.compile('[{}]'.format(re.escape(irc_bad_chars)))
 
+
 def irc_clean(dirty):
-    return irc_clean_re.sub('',dirty)
+    return irc_clean_re.sub('', dirty)
+
 
 irc_command_to_event_type = {
     "PRIVMSG": EventType.message,
@@ -218,13 +223,15 @@ def _send(self, line):
         :type line: str
         """
         logger.info("[{}] >> {}".format(self.name, line))
-        asyncio.async(self._protocol.send(line), loop=self.loop)
-
+        async_util.wrap_future(self._protocol.send(line), loop=self.loop)
 
     @property
     def connected(self):
         return self._connected
 
+    def is_nick_valid(self, nick):
+        return bool(irc_nick_re.fullmatch(nick))
+
 
 class _IrcProtocol(asyncio.Protocol):
     """
@@ -272,24 +279,54 @@ def connection_lost(self, exc):
             # we've been closed intentionally, so don't reconnect
             return
         logger.error("[{}] Connection lost: {}".format(self.conn.name, exc))
-        asyncio.async(self.conn.connect(), loop=self.loop)
+        async_util.wrap_future(self.conn.connect(), loop=self.loop)
 
     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)
         logger.info("[{}] EOF received.".format(self.conn.name))
-        asyncio.async(self.conn.connect(), loop=self.loop)
+        async_util.wrap_future(self.conn.connect(), loop=self.loop)
         return True
 
     @asyncio.coroutine
     def send(self, line):
         # make sure we are connected before sending
         if not self._connected:
             yield from self._connected_future
-        line = line[:510] + "\r\n"
-        data = line.encode("utf-8", "replace")
-        self._transport.write(data)
+
+        old_line = line
+        filtered = bool(self.bot.plugin_manager.out_sieves)
+
+        for out_sieve in self.bot.plugin_manager.out_sieves:
+            event = IrcOutEvent(
+                bot=self.bot, hook=out_sieve, conn=self.conn, irc_raw=line
+            )
+
+            ok, new_line = yield from self.bot.plugin_manager.internal_launch(out_sieve, event)
+            if not ok:
+                logger.warning("Error occurred in outgoing sieve, falling back to old behavior")
+                logger.debug("Line was: %s", line)
+                filtered = False
+                break
+
+            line = new_line
+            if line is not None and not isinstance(line, bytes):
+                line = str(line)
+
+            if not line:
+                return
+
+        if not filtered:
+            # No outgoing sieves loaded or one of the sieves errored, fall back to old behavior
+            line = old_line[:510] + "\r\n"
+            line = line.encode("utf-8", "replace")
+
+        if not isinstance(line, bytes):
+            # the line must be encoded before we send it, one of the sieves didn't encode it, fall back to the default
+            line = line.encode("utf-8", "replace")
+
+        self._transport.write(line)
 
     def data_received(self, data):
         self._input_buffer += data
@@ -339,7 +376,7 @@ def data_received(self, data):
             # Reply to pings immediately
 
             if command == "PING":
-                asyncio.async(self.send("PONG " + command_params[-1]), loop=self.loop)
+                async_util.wrap_future(self.send("PONG " + command_params[-1]), loop=self.loop)
 
             # Parse the command and params
 
@@ -406,13 +443,4 @@ def data_received(self, data):
                           irc_prefix=prefix, irc_command=command, irc_paramlist=command_params, irc_ctcp_text=ctcp_text)
 
             # handle the message, async
-            asyncio.async(self.bot.process(event), loop=self.loop)
-
-# Channel Commands
-# NOTICE #chan :Text
-# PRIVMSG #chan :Text
-# KICK #chan nick :reason
-# JOIN #chan
-# PART #chan :reason
-# MODE #chan +<modes>
-# INVITE nick :#chan
+            async_util.wrap_future(self.bot.process(event), loop=self.loop)

cloudbot/event.py

@@ -2,6 +2,12 @@
 import concurrent.futures
 import enum
 import logging
+import warnings
+from functools import partial
+
+import sys
+
+from cloudbot.util.parsers.irc import Message
 
 logger = logging.getLogger("cloudbot")
 
@@ -153,7 +159,7 @@ def prepare(self):
             # we're running a coroutine hook with a db, so initialise an executor pool
             self.db_executor = concurrent.futures.ThreadPoolExecutor(1)
             # be sure to initialize the db in the database executor, so it will be accessible in that thread.
-            self.db = yield from self.async(self.bot.db_session)
+            self.db = yield from self.async_call(self.bot.db_session)
 
     def prepare_threaded(self):
         """
@@ -189,7 +195,7 @@ def close(self):
         if self.db is not None:
             #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(self.db.close)
+            yield from self.async_call(self.db.close)
             self.db = None
 
     def close_threaded(self):
@@ -310,17 +316,42 @@ def has_permission(self, permission, notice=True):
         return self.conn.permissions.has_perm_mask(self.mask, permission, notice=notice)
 
     @asyncio.coroutine
-    def async(self, function, *args, **kwargs):
+    def async_call(self, func, *args, **kwargs):
         if self.db_executor is not None:
             executor = self.db_executor
         else:
             executor = None
-        if kwargs:
-            result = yield from self.loop.run_in_executor(executor, function, *args)
-        else:
-            result = yield from self.loop.run_in_executor(executor, lambda: function(*args, **kwargs))
+
+        part = partial(func, *args, **kwargs)
+        result = yield from self.loop.run_in_executor(executor, part)
         return result
 
+    def is_nick_valid(self, nick):
+        """
+        Returns whether a nick is valid for a given connection
+        :param nick: The nick to check
+        :return: Whether or not it is valid
+        """
+        return self.conn.is_nick_valid(nick)
+
+    if sys.version_info < (3, 7, 0):
+        # noinspection PyCompatibility
+        @asyncio.coroutine
+        def async_(self, function, *args, **kwargs):
+            warnings.warn(
+                "event.async() is deprecated, use event.async_call() instead.",
+                DeprecationWarning, stacklevel=2
+            )
+            result = yield from self.async_call(function, *args, **kwargs)
+            return result
+
+
+# Silence deprecation warnings about use of the 'async' name as a function
+try:
+    setattr(Event, 'async', getattr(Event, 'async_'))
+except AttributeError:
+    pass
+
 
 class CommandEvent(Event):
     """
@@ -390,3 +421,43 @@ def __init__(self, *args, cap, cap_param=None, **kwargs):
         super().__init__(*args, **kwargs)
         self.cap = cap
         self.cap_param = cap_param
+
+
+class IrcOutEvent(Event):
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.parsed_line = None
+
+    @asyncio.coroutine
+    def prepare(self):
+        yield from super().prepare()
+
+        if "parsed_line" in self.hook.required_args:
+            try:
+                self.parsed_line = Message.parse(self.line)
+            except Exception:
+                logger.exception("Unable to parse line requested by hook %s", self.hook)
+                self.parsed_line = None
+
+    def prepare_threaded(self):
+        super().prepare_threaded()
+
+        if "parsed_line" in self.hook.required_args:
+            try:
+                self.parsed_line = Message.parse(self.line)
+            except Exception:
+                logger.exception("Unable to parse line requested by hook %s", self.hook)
+                self.parsed_line = None
+
+    @property
+    def line(self):
+        return str(self.irc_raw)
+
+
+class PostHookEvent(Event):
+    def __init__(self, *args, launched_hook=None, launched_event=None, result=None, error=None, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.launched_hook = launched_hook
+        self.launched_event = launched_event
+        self.result = result
+        self.error = error