Add basic irc_out hooks to allow outward filtering

Author: linuxdaemon

cloudbot/clients/irc.py

@@ -6,7 +6,7 @@
 from ssl import SSLContext
 
 from cloudbot.client import Client
-from cloudbot.event import Event, EventType
+from cloudbot.event import Event, EventType, IrcOutEvent
 
 logger = logging.getLogger("cloudbot")
 
@@ -287,9 +287,20 @@ 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)
+
+        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, not sending line")
+                logger.debug("Line was: %s", line)
+                return
+
+            line = new_line
+            if not line:
+                return
+
+        self._transport.write(line)
 
     def data_received(self, data):
         self._input_buffer += data

cloudbot/event.py

@@ -390,3 +390,9 @@ def __init__(self, *args, cap, cap_param=None, **kwargs):
         super().__init__(*args, **kwargs)
         self.cap = cap
         self.cap_param = cap_param
+
+
+class IrcOutEvent(Event):
+    @property
+    def line(self):
+        return self.irc_raw

cloudbot/hook.py

@@ -439,3 +439,19 @@ def _on_connect_hook(func):
 
 
 connect = on_connect
+
+
+def irc_out(param=None, **kwargs):
+    def _on_connect_hook(func):
+        hook = _get_hook(func, "irc_out")
+        if hook is None:
+            hook = _Hook(func, "irc_out")
+            _add_hook(func, hook)
+
+        hook._add_hook(kwargs)
+        return func
+
+    if callable(param):
+        return _on_connect_hook(param)
+    else:
+        return lambda func: _on_connect_hook(func)

cloudbot/plugin.py

@@ -6,8 +6,8 @@
 import os
 import re
 from collections import defaultdict
-from operator import attrgetter
 from itertools import chain
+from operator import attrgetter
 
 import sqlalchemy
 
@@ -37,9 +37,10 @@ def find_hooks(parent, module):
     on_cap_ack = []
     on_cap_available = []
     on_connect = []
+    out_sieve = []
     type_lists = {"command": command, "regex": regex, "irc_raw": raw, "sieve": sieve, "event": event,
                   "periodic": periodic, "on_start": on_start, "on_stop": on_stop, "on_cap_ack": on_cap_ack,
-                  "on_cap_available": on_cap_available, "on_connect": on_connect}
+                  "on_cap_available": on_cap_available, "on_connect": on_connect, "irc_out": out_sieve}
     for name, func in module.__dict__.items():
         if hasattr(func, "_cloudbot_hook"):
             # if it has cloudbot hook
@@ -51,7 +52,7 @@ def find_hooks(parent, module):
             # delete the hook to free memory
             del func._cloudbot_hook
 
-    return command, regex, raw, sieve, event, periodic, on_start, on_stop, on_cap_ack, on_cap_available, on_connect
+    return command, regex, raw, sieve, event, periodic, on_start, on_stop, on_cap_ack, on_cap_available, on_connect, out_sieve
 
 
 def find_tables(code):
@@ -108,6 +109,7 @@ def __init__(self, bot):
         self.sieves = []
         self.cap_hooks = {"on_available": defaultdict(list), "on_ack": defaultdict(list)}
         self.connect_hooks = []
+        self.out_sieves = []
         self._hook_waiting_queues = {}
 
     @asyncio.coroutine
@@ -429,27 +431,36 @@ def _execute_hook_sync(self, hook, event):
             yield from event.close()
 
     @asyncio.coroutine
-    def _execute_hook(self, hook, event):
+    def internal_launch(self, hook, event):
         """
-        Runs the specific hook with the given bot and event.
-
-        Returns False if the hook errored, True otherwise.
-
-        :type hook: cloudbot.plugin.Hook
-        :type event: cloudbot.event.Event
-        :rtype: bool
+        Launches a hook with the data from [event]
+        :param hook: The hook to launch
+        :param event: The event providing data for the hook
+        :return: a tuple of (ok, result) where ok is a boolean that determines if the hook ran without error and result is the result from the hook
         """
         try:
-            # _internal_run_threaded and _internal_run_coroutine prepare the database, and run the hook.
-            # _internal_run_* will prepare parameters and the database session, but won't do any error catching.
             if hook.threaded:
                 out = yield from self.bot.loop.run_in_executor(None, self._execute_hook_threaded, hook, event)
             else:
                 out = yield from self._execute_hook_sync(hook, event)
         except Exception:
             logger.exception("Error in hook {}".format(hook.description))
-            return False
+            return False, None
+
+        return True, out
 
+    @asyncio.coroutine
+    def _execute_hook(self, hook, event):
+        """
+        Runs the specific hook with the given bot and event.
+
+        Returns False if the hook errored, True otherwise.
+
+        :type hook: cloudbot.plugin.Hook
+        :type event: cloudbot.event.Event
+        :rtype: bool
+        """
+        ok, out = yield from self.internal_launch(hook, event)
         if out is not None:
             if isinstance(out, (list, tuple)):
                 # if there are multiple items in the response, return them on multiple lines
@@ -878,6 +889,17 @@ def __str__(self):
         return "{name} {func} from {file}".format(name=self.type, func=self.function_name, file=self.plugin.file_name)
 
 
+class IrcOutHook(Hook):
+    def __init__(self, plugin, out_hook):
+        super().__init__("irc_out", plugin, out_hook)
+
+    def __repr__(self):
+        return "Irc_Out[{}]".format(Hook.__repr__(self))
+
+    def __str__(self):
+        return "irc_out {} from {}".format(self.function_name, self.plugin.file_name)
+
+
 _hook_name_to_plugin = {
     "command": CommandHook,
     "regex": RegexHook,
@@ -890,4 +912,5 @@ def __str__(self):
     "on_cap_available": OnCapAvaliableHook,
     "on_cap_ack": OnCapAckHook,
     "on_connect": OnConnectHook,
+    "irc_out": IrcOutHook,
 }

plugins/core_out.py

@@ -0,0 +1,43 @@
+"""
+Core filters for IRC raw lines
+"""
+
+from cloudbot import hook
+from cloudbot.hook import Priority
+
+NEW_LINE_TRANS_TBL = str.maketrans({
+    '\r': None,
+    '\n': None,
+    '\0': None,
+})
+
+
+@hook.irc_out(priority=Priority.HIGHEST)
+def strip_newlines(line, conn):
+    """
+    Removes newline characters from a message
+    :param line: str
+    :param conn: cloudbot.clients.irc.IrcClient
+    :return: str
+    """
+    do_strip = conn.config.get("strip_newlines", True)
+    if do_strip:
+        return line.translate(NEW_LINE_TRANS_TBL)
+    else:
+        return line
+
+
+@hook.irc_out(priority=Priority.HIGH)
+def truncate_line(line, conn):
+    line_len = conn.config.get("max_line_length", 510)
+    return line[:line_len] + "\r\n"
+
+
+@hook.irc_out(priority=Priority.LOWEST)
+def encode_line(line, conn):
+    if not isinstance(line, str):
+        return line
+
+    encoding = conn.config.get("encoding", "utf-8")
+    errors = conn.config.get("encoding_errors", "replace")
+    return line.encode(encoding, errors)