Refactor CAP and sasl plugins

Author: linuxdaemon

cloudbot/clients/irc.py

@@ -202,7 +202,7 @@ def cmd(self, command, *params):
         :type command: str
         :type params: (str)
         """
-        params = list(params)  # turn the tuple of parameters into a list
+        params = list(map(str, params))  # turn the tuple of parameters into a list
         if params:
             params[-1] = ':' + params[-1]
             self.send("{} {}".format(command, ' '.join(params)))

cloudbot/util/parsers/irc.py

@@ -70,8 +70,11 @@ def __eq__(self, other):
 
         return NotImplemented
 
+    def __hash__(self):
+        return hash((self.name, self.value))
+
     @staticmethod
-    def parse(text: str):
+    def parse(text):
         """Parse a CAP entity from a string"""
         name, _, value = text.partition(CAP_VALUE_SEP)
         return Cap(name, value)
@@ -81,7 +84,7 @@ class CapList(Parseable, list):
     """Represents a list of CAP entities"""
 
     def __str__(self):
-        return CAP_SEP.join(self)
+        return CAP_SEP.join(map(str, self))
 
     @staticmethod
     def parse(text):

plugins/core/cap.py

@@ -1,34 +1,36 @@
 import asyncio
-import logging
+import inspect
 from functools import partial
 
 from cloudbot import hook
 from cloudbot.event import CapEvent
+from cloudbot.util import async_util
+from cloudbot.util.parsers.irc import CapList
 
-logger = logging.getLogger("cloudbot")
 
-
-@asyncio.coroutine
 @hook.connect(priority=-10)
 def send_cap_ls(conn):
     conn.cmd("CAP", "LS", "302")
+    conn.memory.setdefault("available_caps", set()).clear()
+    conn.memory.setdefault("cap_queue", {}).clear()
 
 
 @asyncio.coroutine
 def handle_available_caps(conn, caplist, event, irc_paramlist, bot):
-    available_caps = conn.memory.setdefault("available_caps", set())
-    caps = [tuple(cap.split('=', 1)) for cap in caplist]
-    available_caps.update(caps)
-    cap_queue = conn.memory.setdefault("cap_queue", {})
-    for cap, *param in caps:
-        cap_event = partial(CapEvent, base_event=event, cap=cap, cap_param=param[0] if param else None)
+    available_caps = conn.memory["available_caps"]
+    available_caps.update(caplist)
+    cap_queue = conn.memory["cap_queue"]
+    for cap in caplist:
+        name = cap.name
+        name_cf = name.casefold()
+        cap_event = partial(CapEvent, base_event=event, cap=name, cap_param=cap.value)
         tasks = [
-            bot.plugin_manager.launch(_hook, cap_event(hook=_hook))
-            for _hook in bot.plugin_manager.cap_hooks["on_available"][cap.casefold()]
+            bot.plugin_manager.internal_launch(_hook, cap_event(hook=_hook))
+            for _hook in bot.plugin_manager.cap_hooks["on_available"][name_cf]
         ]
         results = yield from asyncio.gather(*tasks)
-        if any(results):
-            cap_queue[cap.casefold()] = conn.loop.create_future()
+        if any(ok and (res or res is None) for ok, res in results):
+            cap_queue[name_cf] = conn.loop.create_future()
             conn.cmd("CAP", "REQ", cap)
 
     if irc_paramlist[2] != '+':
@@ -37,46 +39,111 @@ def handle_available_caps(conn, caplist, event, irc_paramlist, bot):
         conn.send("CAP END")
 
 
+HANDLERS = {}
+
+
+def _subcmd_handler(*types):
+    def _decorate(func):
+        for subcmd in types:
+            HANDLERS[subcmd.upper()] = func
+
+        return func
+
+    return lambda func: _decorate(func)
+
+
+@asyncio.coroutine
+def _launch_handler(subcmd, event, **kwargs):
+    subcmd = subcmd.upper()
+    kwargs["subcmd"] = subcmd
+    handler = HANDLERS.get(subcmd)
+    if handler:
+        sig = inspect.signature(handler)
+        args = []
+
+        for arg in sig.parameters.keys():
+            if arg in kwargs:
+                args.append(kwargs[arg])
+            else:
+                try:
+                    value = getattr(event, arg)
+                except AttributeError:
+                    event.logger.warning("CAP subcommand handler requested unknown argument: %s", arg)
+                    return
+                else:
+                    args.append(value)
+
+        yield from async_util.run_func(event.loop, handler, *args)
+
+
+@asyncio.coroutine
+@_subcmd_handler("LS")
+def cap_ls(conn, caplist, event, irc_paramlist, bot, logger):
+    logger.info("Available capabilities: %s", caplist)
+    yield from handle_available_caps(conn, caplist, event, irc_paramlist, bot)
+
+
+@asyncio.coroutine
+def handle_req_resp(enabled, conn, caplist, event, bot):
+    server_caps = conn.memory.setdefault('server_caps', {})
+    cap_queue = conn.memory.get("cap_queue", {})
+    caps = (cap.name.casefold() for cap in caplist)
+    for cap in caps:
+        server_caps[cap] = enabled
+        if enabled:
+            cap_event = partial(CapEvent, base_event=event, cap=cap)
+            tasks = [
+                bot.plugin_manager.launch(_hook, cap_event(hook=_hook))
+                for _hook in bot.plugin_manager.cap_hooks["on_ack"][cap]
+            ]
+            yield from asyncio.gather(*tasks)
+
+        if cap in cap_queue:
+            cap_queue[cap].set_result(enabled)
+
+
+@asyncio.coroutine
+@_subcmd_handler("ACK")
+def cap_ack_nak(conn, caplist, event, bot):
+    yield from handle_req_resp(True, conn, caplist, event, bot)
+
+
+@asyncio.coroutine
+@_subcmd_handler("NAK")
+def cap_nak(conn, caplist, event, bot):
+    yield from handle_req_resp(False, conn, caplist, event, bot)
+
+
+@_subcmd_handler("LIST")
+def cap_list(logger, caplist):
+    logger.info("Enabled Capabilities: %s", caplist)
+
+
+@asyncio.coroutine
+@_subcmd_handler("NEW")
+def cap_new(logger, caplist, conn, event, bot, irc_paramlist):
+    logger.info("New capabilities advertised: %s", caplist)
+    yield from handle_available_caps(conn, caplist, event, irc_paramlist, bot)
+
+
+@_subcmd_handler("DEL")
+def cap_del(logger, conn, caplist):
+    # TODO add hooks for CAP removal
+    logger.info("Capabilities removed by server: %s", caplist)
+    server_caps = conn.memory.setdefault('server_caps', {})
+    for cap in caplist:
+        server_caps[cap.name.casefold()] = False
+
+
 @asyncio.coroutine
 @hook.irc_raw("CAP")
-def on_cap(irc_paramlist, conn, bot, event):
-    caplist = []
+def on_cap(irc_paramlist, event):
+    args = {}
     if len(irc_paramlist) > 2:
         capstr = irc_paramlist[-1].strip()
         if capstr[0] == ':':
             capstr = capstr[1:]
 
-        caplist = capstr.split()
-    subcmd = irc_paramlist[1].upper()
-    if subcmd == "LS":
-        yield from handle_available_caps(conn, caplist, event, irc_paramlist, bot)
-
-    elif subcmd in ('ACK', 'NAK'):
-        enabled = subcmd == 'ACK'
-        server_caps = conn.memory.setdefault('server_caps', {})
-        cap_queue = conn.memory.get("cap_queue", {})
-        caps = [cap.casefold() for cap in caplist]
-        for cap in caps:
-            server_caps[cap] = enabled
-            if enabled:
-                cap_event = partial(CapEvent, base_event=event, cap=cap)
-                tasks = [
-                    bot.plugin_manager.launch(_hook, cap_event(hook=_hook))
-                    for _hook in bot.plugin_manager.cap_hooks["on_ack"][cap]
-                ]
-                yield from asyncio.gather(*tasks)
-
-            if cap in cap_queue:
-                cap_queue[cap].set_result(enabled)
-
-    elif subcmd == 'LIST':
-        logger.info("Enabled Capabilities: %s", irc_paramlist[-1])
-    elif subcmd == 'NEW':
-        logger.info("New capabilities advertised: %s", irc_paramlist[-1])
-        yield from handle_available_caps(conn, caplist, event, irc_paramlist, bot)
-    elif subcmd == 'DEL':
-        # TODO add hooks for CAP removal
-        logger.info("Capabilities removed by server: %s", irc_paramlist[-1])
-        server_caps = conn.memory.setdefault('server_caps', {})
-        for cap in caplist:
-            server_caps[cap] = False
+        args["caplist"] = CapList.parse(capstr)
+
+    yield from _launch_handler(irc_paramlist[1], event, **args)

plugins/sasl.py

@@ -1,22 +1,20 @@
 import asyncio
 import base64
-import logging
 
 from cloudbot import hook
 
-logger = logging.getLogger("cloudbot")
-
 
 @hook.on_cap_available("sasl")
-def sasl_available():
-    pass
+def sasl_available(conn):
+    sasl_conf = conn.config.get('sasl')
+    return bool(sasl_conf and sasl_conf.get('enabled', True))
 
 
 @asyncio.coroutine
 @hook.on_cap_ack("sasl")
-def sasl_ack(conn):
+def sasl_ack(conn, logger):
     sasl_auth = conn.config.get('sasl')
-    if sasl_auth:
+    if sasl_auth and sasl_auth.get('enabled', True):
         sasl_mech = sasl_auth.get("mechanism", "PLAIN").upper()
         auth_fut = conn.loop.create_future()
         conn.memory["sasl_auth_future"] = auth_fut