Renovate the module system and implement adding and resuming pool instances using the new relay/alias/network system

commands/add.py

@@ -1,111 +0,0 @@
-import main
-import core.helper as helper
-
-class Add:
-    def __init__(self, register):
-        register("add", self.add)
-
-    def add(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
-        if authed:
-            if length > 6:
-                failure("Too many arguments")
-                return
-
-            if length > 1:
-                name = spl[1]
-                if name.isdigit():
-                    failure("Network name is all numbers. This will break things.")
-                    return
-            else:
-                incUsage("add")
-                return
-            if length > 2:
-                host = spl[2]
-            if length > 3:
-                port = spl[3]
-            if length > 4:
-                protocol = spl[4]
-            if length > 5:
-                nickname = spl[5]
-
-            toFail = False
-            if length < 6:
-                if main.config["Default"]["nickname"] == None:
-                    failure("Choose a nickname, or configure one in defaults")
-                    toFail = True
-                else:
-                    nickname = main.config["Default"]["nickname"]
-
-            if length < 5:
-                if main.config["Default"]["protocol"] == None:
-                    failure("Choose a protocol, or configure one in defaults")
-                    toFail = True
-                else:
-                    protocol = main.config["Default"]["protocol"]
-
-            if length < 4:
-                if main.config["Default"]["port"] == None:
-                    failure("Choose a port, or configure one in defaults")
-                    toFail = True
-                else:
-                    port = main.config["Default"]["port"]
-
-            if length < 3:
-                if main.config["Default"]["host"] == None:
-                    failure("Choose a host, or configure one in defaults")
-                    toFail = True
-                else:
-                    host = main.config["Default"]["host"]
-            if toFail:
-                failure("Stopping due to previous error(s)")
-                return
-
-            if length < 2:
-                incUsage("add")
-                return
-
-            if name in main.pool.keys():
-                failure("Name already exists: %s" % name)
-                return
-
-            protocol = protocol.lower()
-
-            if not protocol in ["ssl", "plain"]:
-                failure("Protocol must be ssl or plain, not %s" % protocol)
-                return
-
-            if not port.isdigit():
-                failure("Port must be an integer, not %s" % port)
-                return
-
-            main.pool[name] = { "host": host,
-                             "port": port,
-                             "protocol": protocol,
-                             "bind": main.config["Default"]["bind"],
-                             "timeout": main.config["Default"]["timeout"],
-                             "maxdelay": main.config["Default"]["maxdelay"],
-                             "initialdelay": main.config["Default"]["initialdelay"],
-                             "factor": main.config["Default"]["factor"],
-                             "jitter": main.config["Default"]["jitter"],
-                             "nickname": nickname,
-                             "username": main.config["Default"]["username"],
-                             "realname": main.config["Default"]["realname"],
-                             "userinfo": main.config["Default"]["userinfo"],
-                             "finger": main.config["Default"]["finger"],
-                             "version": main.config["Default"]["version"],
-                             "source": main.config["Default"]["source"],
-                             "autojoin": main.config["Default"]["autojoin"],
-                             "authtype": main.config["Default"]["authtype"],
-                             "password": main.config["Default"]["password"],
-                             "authentity": main.config["Default"]["authentity"],
-                             "key": main.config["Default"]["key"],
-                             "certificate": main.config["Default"]["certificate"],
-                             "enabled": main.config["ConnectOnCreate"],
-                           }
-            if main.config["ConnectOnCreate"] == True:
-                helper.addBot(name)
-            success("Successfully created bot")
-            main.saveConf("pool")
-            return
-        else:
-            incUsage(None)

commands/alias.py

@@ -2,8 +2,8 @@ import main
 from yaml import dump
 
 class Alias:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("alias", self.alias)
+        self.alias(*args)
 
     def alias(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/chans.py

@@ -2,8 +2,8 @@ import main
 import modules.userinfo as userinfo
 
 class Chans:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("chans", self.chans)
+        self.chans(*args)
 
     def chans(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/cmd.py

@@ -0,0 +1,24 @@
+import main
+from core.bot import deliverRelayCommands
+
+class Cmd:
+    def __init__(self, *args):
+        self.cmd(*args)
+
+    def cmd(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
+        if authed:
+            if length > 4:
+                if not spl[1] in main.relay.keys():
+                    failure("No such relay: %s" % spl[1])
+                    return
+
+                commands = {spl[3]: [" ".join(spl[4:])]}
+                print(" ".join(spl[4:]))
+                success("Sending commands to relay %s as user %s" % (spl[1], spl[2]))
+                deliverRelayCommands(spl[1], commands, user=spl[2])
+                return
+            else:
+                incUsage("cmd")
+                return
+        else:
+            incUsage(None)

commands/del.py

@@ -1,8 +1,8 @@
 import main
 
-class Delete:
+class Del:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("del", self.delete)
+        self.delete(*args)
 
     def delete(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/disable.py

@@ -1,8 +1,9 @@
 import main
+from core.bot import deliverRelayCommands
 
 class Disable:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("disable", self.disable)
+        self.disable(*args)
 
     def disable(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:
@@ -11,6 +12,11 @@ class Disable:
                     failure("Name does not exist: %s" % spl[1])
                     return
                 main.pool[spl[1]]["enabled"] = False
+                user = main.pool[spl[1]]["alias"]
+                network = main.pool[spl[1]]["network"]
+                relay = main.pool[spl[1]]["relay"]
+                commands = {"status": ["Disconnect"]}
+                deliverRelayCommands(relay, commands, user=user+"/"+network)
                 main.saveConf("pool")
                 if spl[1] in main.ReactorPool.keys():
                     if spl[1] in main.FactoryPool.keys():

commands/dist.py

@@ -2,8 +2,8 @@ import main
 from subprocess import run, PIPE
 
 class Dist:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("dist", self.dist)
+        self.dist(*args)
 
     def dist(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/enable.py

@@ -1,9 +1,10 @@
 import main
-import core.helper as helper
+from core.helper import startBot
+from core.bot import deliverRelayCommands
 
 class Enable:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("enable", self.enable)
+        self.enable(*args)
 
     def enable(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:
@@ -12,9 +13,14 @@ class Enable:
                     failure("Name does not exist: %s" % spl[1])
                     return
                 main.pool[spl[1]]["enabled"] = True
+                user = main.pool[spl[1]]["alias"]
+                network = main.pool[spl[1]]["network"]
+                relay = main.pool[spl[1]]["relay"]
+                commands = {"status": ["Connect"]}
+                deliverRelayCommands(relay, commands, user=user+"/"+network)
                 main.saveConf("pool")
                 if not spl[1] in main.IRCPool.keys():
-                    helper.addBot(spl[1])
+                    startBot(spl[1])
                 else:
                     pass
                 success("Successfully enabled bot %s" % spl[1])

commands/get.py

@@ -1,8 +1,8 @@
 import main
 
 class Get:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("get", self.get)
+        self.get(*args)
 
     def get(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/help.py

@@ -1,8 +1,8 @@
 import main
 
 class Help:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("help", self.help)
+        self.help(*args)
 
     def help(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/join.py

@@ -1,8 +1,8 @@
 import main
 
 class Join:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("join", self.join)
+        self.join(*args)
 
     def join(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/key.py

@@ -2,8 +2,8 @@ import main
 import modules.keyword as keyword
 
 class Key:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("key", self.key)
+        self.key(*args)
 
     def key(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/list.py

@@ -2,8 +2,8 @@ import main
 from yaml import dump
 
 class List:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("list", self.list)
+        self.list(*args)
 
     def list(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/load.py

@@ -1,8 +1,8 @@
 import main
 
 class Load:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("load", self.load)
+        self.list(*args)
 
     def load(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/loadmod.py

@@ -2,15 +2,18 @@ import main
 from utils.loaders.single_loader import loadSingle
 
 class Loadmod:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("loadmod", self.loadmod)
+        self.loadmod(*args)
 
     def loadmod(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:
             if length == 2:
-                rtrn = loadSingle(spl[1], main.register)
+                rtrn = loadSingle(spl[1])
                 if rtrn == True:
-                    success("Loaded module %s" % spl[1])
+                    success("Loaded module: %s" % spl[1])
+                    return
+                elif rtrn == "RELOAD":
+                    success("Reloaded module: %s" % spl[1])
                     return
                 else:
                     failure("Error loading module %s: %s" % (spl[1], rtrn))

commands/logout.py

@@ -1,8 +1,8 @@
 import main
 
 class Logout:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("logout", self.logout)
+        self.logout(*args)
 
     def logout(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/mod.py

@@ -2,12 +2,11 @@ import main
 from yaml import dump
 
 class Mod:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("mod", self.mod)
+        self.mod(*args)
 
     def mod(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:
-            toUnset = False
             if length == 2:
                 if not spl[1] in main.pool.keys():
                     failure("Name does not exist: %s" % spl[1])
@@ -33,50 +32,16 @@ class Mod:
                     failure("No such key: %s" % spl[2])
                     return
 
-                if spl[2] == "protocol":
-                    if not spl[3] in ["ssl", "plain"]:
-                        failure("Protocol must be ssl or plain, not %s" % spl[3])
-                        return
                 if spl[3] == main.pool[spl[1]][spl[2]]:
                     failure("Value already exists: %s" % spl[3])
                     return
 
-                if spl[3].lower() in ["none", "nil"]:
-                    spl[3] = None
-                    toUnset = True
-
-                if spl[2] in ["port", "timeout", "maxdelay"]:
-                    try:
-                        spl[3] = int(spl[3])
-                    except:
-                        failure("Value must be an integer, not %s" % spl[3])
-                        return
-
-                if spl[2] in ["initialdelay", "factor", "jitter"]:
-                    try:
-                        spl[3] = float(spl[3])
-                    except:
-                        failure("Value must be a floating point integer, not %s" % spl[3])
-                        return
-
-                if spl[2] == "authtype":
-                    if not toUnset:
-                        if not spl[3] in ["sp", "ns"]:
-                            failure("Authtype must be sp or ns, not %s" % spl[3])
-                            return
                 if spl[2] == "enabled":
                     failure("Use the enable and disable commands to manage this")
                     return
-                if spl[2] == "autojoin":
-                    spl[3] = spl[3].split(",")
 
                 main.pool[spl[1]][spl[2]] = spl[3]
-                if spl[1] in main.IRCPool.keys():
-                    main.IRCPool[spl[1]].refresh()
                 main.saveConf("pool")
-                if toUnset:
-                    success("Successfully unset key %s on %s" % (spl[2], spl[1]))
-                else:
                 success("Successfully set key %s to %s on %s" % (spl[2], spl[3], spl[1]))
                 return
 

commands/mon.py

@@ -5,8 +5,8 @@ from io import StringIO
 from yaml import dump
 
 class Mon:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("mon", self.mon)
+        self.mon(*args)
 
     def setup_arguments(self, ArgumentParser):
         self.parser = ArgumentParser(prog="mon", description="Manage monitors. Extremely flexible. All arguments are optional.")

commands/msg.py

@@ -1,8 +1,8 @@
 import main
 
 class Msg:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("msg", self.msg)
+        self.msg(*args)
 
     def msg(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/network.py

@@ -2,8 +2,8 @@ import main
 from yaml import dump
 
 class Network:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("network", self.network)
+        self.network(*args)
 
     def network(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/part.py

@@ -1,8 +1,8 @@
 import main
 
 class Part:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("part", self.part)
+        self.part(*args)
 
     def part(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/pass.py

@@ -1,8 +1,8 @@
 import main
 
-class Password:
+class Pass:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("pass", self.password)
+        self.password(*args)
 
     def password(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/provision.py

@@ -2,8 +2,8 @@ import main
 from modules import provision
 
 class Provision:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("provision", self.provision)
+        self.provision(*args)
 
     def provision(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/relay.py

@@ -2,8 +2,8 @@ import main
 from yaml import dump
 
 class Relay:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("relay", self.relay)
+        self.relay(*args)
 
     def relay(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/save.py

@@ -1,8 +1,8 @@
 import main
 
 class Save:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("save", self.save)
+        self.save(*args)
 
     def save(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/stats.py

@@ -4,8 +4,8 @@ import modules.userinfo as userinfo
 from string import digits
 
 class Stats:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("stats", self.stats)
+        self.stats(*args)
 
     def stats(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/users.py

@@ -2,8 +2,8 @@ import main
 import modules.userinfo as userinfo
 
 class Users:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("users", self.users)
+        self.users(*args)
 
     def users(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

commands/who.py

@@ -2,8 +2,8 @@ import main
 import modules.userinfo as userinfo
 
 class Who:
-    def __init__(self, register):
+    def __init__(self, *args):
-        register("who", self.who)
+        self.who(*args)
 
     def who(self, addr, authed, data, obj, spl, success, failure, info, incUsage, length):
         if authed:

conf/help.json

@@ -23,5 +23,6 @@
     "alias": "alias <add|del|list> [<alias> <nickname> <altnick> <ident> <realname> <password>]",
     "relay": "relay <add|del|list> [<relay> <host> <port> <user> <password>]",
     "network": "network <add|del|list> [<name> <address> <port> <ssl|plain> <sasl|ns|none>]",
-    "provision": "provision <relay> <alias> [<network>]"
+    "provision": "provision <relay> <alias> [<network>]",
+    "cmd": "cmd <relay> <user> <entity> <text ...>"
 }

core/bot.py

@@ -95,44 +95,27 @@ class IRCBot(IRCClient):
             error("Network with all numbers: %s" % name)
         self.buffer = ""
         self.name = name
-        instance = main.pool[name]
+        inst = main.pool[name]
+        alias = main.alias[inst["alias"]]
+        relay = main.relay[inst["relay"]]
+        network = main.network[inst["network"]]
 
-        self.nickname = instance["nickname"]
+        self.nickname = alias["nick"]
-        self.realname = instance["realname"]
+        self.realname = alias["realname"]
-        self.username = instance["username"]
+        self.username = inst["alias"]+"/"+inst["network"]
-        self.userinfo = instance["userinfo"]
+        self.password = relay["password"]
-        self.fingerReply = instance["finger"]
+        self.userinfo = None
-        self.versionName = instance["version"]
+        self.fingerReply = None
+        self.versionName = None
         self.versionNum = None
         self.versionEnv = None
-        self.sourceURL = instance["source"]
+        self.sourceURL = None
-        self.autojoin = instance["autojoin"]
 
         self._who = {}
         self._getWho = {}
 
         self._names = {}
 
-        self.authtype = instance["authtype"]
-        if self.authtype == "ns":
-            self.authpass = instance["password"]
-            self.authentity = instance["authentity"]
-        else:
-            self.password = instance["password"]
-
-    def refresh(self):
-        instance = main.pool[self.name]
-        if not instance["nickname"] == self.nickname:
-            self.nickname = instance["nickname"]
-            self.setNick(self.nickname)
-
-        self.userinfo = instance["userinfo"]
-        self.fingerReply = instance["finger"]
-        self.versionName = instance["version"]
-        self.versionNum = None
-        self.versionEnv = None
-        self.sourceURL = instance["source"]
-
     def parsen(self, user):
         step = user.split("!")
         nick = step[0]
@@ -350,10 +333,6 @@ class IRCBot(IRCClient):
         log("signed on: %s" % self.name)
         if main.config["Notifications"]["Connection"]:
             keyword.sendMaster("SIGNON: %s" % self.name)
-        if self.authtype == "ns":
-            self.msg(self.authentity, "IDENTIFY %s" % self.nspass)
-        for i in self.autojoin:
-            self.join(i)
         count.event(self.net, "signedon")
 
     def joined(self, channel):
@@ -454,7 +433,6 @@ class IRCBotFactory(ReconnectingClientFactory):
     def __init__(self, name, relay=None, relayCommands=None, user=None, stage2=None):
         if not name == None:
             self.name = name
-            self.instance = main.pool[name]
             self.net = "".join([x for x in self.name if not x in digits])
         else:
             self.name = "Relay to "+relay

core/helper.py

@@ -1,39 +1,38 @@
 from twisted.internet import reactor
 from core.bot import IRCBot, IRCBotFactory
+from twisted.internet.ssl import DefaultOpenSSLContextFactory
 import main
 from utils.logging.log import *
 
-def addBot(name):
+def startBot(name):
-    instance = main.pool[name]
+    inst = main.pool[name]
-    log("Started bot %s to %s:%s protocol %s nickname %s" % (name,
+    relay, alias, network = inst["relay"], inst["alias"], inst["network"]
-        instance["host"],
+    host = main.relay[relay]["host"]
-        instance["port"],
+    port = int(main.relay[relay]["port"])
-        instance["protocol"],
-        instance["nickname"]))
 
+    log("Started bot %s to %s network %s" % (name, relay, network))
 
-    if instance["protocol"] == "ssl":
     keyFN = main.certPath+main.config["Key"]
     certFN = main.certPath+main.config["Certificate"]
     contextFactory = DefaultOpenSSLContextFactory(keyFN.encode("utf-8", "replace"),
             certFN.encode("utf-8", "replace"))
-        if instance["bind"] == None:
+    if "bind" in main.relay[relay].keys():
         bot = IRCBotFactory(name)
-            rct = reactor.connectSSL(instance["host"],
+        rct = reactor.connectSSL(host,
-                    int(instance["port"]),
+                port,
-                    bot, contextFactory)
+                bot, contextFactory,
+                bindAddress=main.relay[relay]["bind"])
 
         main.ReactorPool[name] = rct
         main.FactoryPool[name] = bot
         return
     else: 
-
         bot = IRCBotFactory(name)
-            rct = reactor.connectSSL(instance["host"],
+        rct = reactor.connectSSL(host,
-                    int(instance["port"]),
+                port,
-                    bot, contextFactory,
+                bot, contextFactory)
-                    bindAddress=instance["bind"])
 
         main.ReactorPool[name] = rct
         main.FactoryPool[name] = bot
         return
+

core/parser.py

@@ -22,9 +22,8 @@ def parseCommand(addr, authed, data):
     else:
         failure("No text was sent")
         return
-    for i in main.CommandMap.keys():
+    if spl[0] in main.CommandMap.keys():
-        if spl[0] == i:
+        main.CommandMap[spl[0]](addr, authed, data, obj, spl, success, failure, info, incUsage, length)
-            main.CommandMap[i](addr, authed, data, obj, spl, success, failure, info, incUsage, length)
         return
     incUsage(None)
     return

main.py

@@ -1,7 +1,6 @@
 from json import load, dump, loads
-import redis
+from redis import StrictRedis
 from string import digits
-from utils.loaders.command_loader import loadCommands
 from utils.logging.log import *
 
 configPath = "conf/"
@@ -43,13 +42,6 @@ def liveNets():
         networks.add("".join([x for x in i if not x in digits]))
     return networks
 
-def register(command, function):
-    if not command in CommandMap:
-        CommandMap[command] = function
-        debug("Registered command: %s" % command)
-    else:
-        error("Duplicate command: %s" % (command))
-
 def saveConf(var):
     with open(configPath+filemap[var][0], "w") as f:
         dump(globals()[var], f, indent=4)
@@ -66,7 +58,6 @@ def initConf():
 def initMain():
     global r
     initConf()
-    loadCommands(register)
+    r = StrictRedis(unix_socket_path=config["RedisSocket"], db=0)
-    r = redis.StrictRedis(unix_socket_path=config["RedisSocket"], db=0)
 
 

modules/provision.py

@@ -1,6 +1,7 @@
 import main
 from core.bot import deliverRelayCommands
 from utils.logging.log import *
+from core.helper import startBot
 
 def provisionUserData(relay, alias, nick, altnick, ident, realname, password):
     commands = {}
@@ -81,7 +82,10 @@ def provisionRelayForNetwork(relay, alias, network):
         else:
             main.pool[network+i] = {"relay": relay,
                                     "alias": alias,
-                                    "network": network}
+                                    "network": network,
+                                    "enabled": main.config["ConnectOnCreate"]}
             main.saveConf("pool")
+            if main.config["ConnectOnCreate"]:
+                startBot(network+i)
             storedNetwork = True
     return network+i

threshold

@@ -1,7 +1,6 @@
 #!/usr/bin/env python
 from twisted.internet import reactor
 from twisted.internet.ssl import DefaultOpenSSLContextFactory
-
 #from twisted.python import log
 #from sys import stdout
 #log.startLogging(stdout)
@@ -11,10 +10,12 @@ import main
 main.initMain()
 
 from utils.logging.log import *
-import modules.userinfo as userinfo
+from utils.loaders.command_loader import loadCommands
-import core.helper as helper
+from core.helper import startBot
 from core.server import Server, ServerFactory
 
+loadCommands()
+
 if __name__ == "__main__":
     listener = ServerFactory()
     if main.config["Listener"]["UseSSL"] == True:
@@ -27,6 +28,6 @@ if __name__ == "__main__":
         if not "enabled" in main.pool[i]:
             continue
         if main.pool[i]["enabled"] == True:
-            helper.addBot(i)
+            startBot(i)
 
     reactor.run()

utils/loaders/command_loader.py

@@ -1,14 +1,21 @@
 from os import listdir
+
 from utils.logging.log import *
 import commands
 
-def loadCommands(func):
+from main import CommandMap
+
+def loadCommands():
     for filename in listdir('commands'):
         if filename.endswith('.py') and filename != "__init__.py":
             commandName = filename[0:-3]
             className = commandName.capitalize()
             try:
-                    __import__('commands.%s' % commandName)
+                module = __import__('commands.%s' % commandName)
-                    eval('commands.%s.%s(func)' % (commandName, className))
+                if not commandName in CommandMap:
+                    CommandMap[commandName] = getattr(getattr(module, commandName), className)
+                    debug("Registered command: %s" % commandName)
+                else:
+                    error("Duplicate command: %s" % (commandName))
             except Exception as err:
                 error("Exception while loading command %s:\n%s" % (commandName, err))

utils/loaders/single_loader.py

@@ -1,17 +1,26 @@
 from os import listdir
-import main
+from importlib import reload
+from sys import modules
+
 from utils.logging.log import *
 import commands
 
-def loadSingle(command, func):
+from main import CommandMap
-    if command+".py" in listdir("commands"):
+
+def loadSingle(commandName):
+    if commandName+".py" in listdir("commands"):
+        className = commandName.capitalize()
         try:
-                if command in main.CommandMap.keys():
+            if commandName in CommandMap.keys():
-                    return "Cannot reload modules"
+                reload(modules["commands."+commandName])
-                else:
+                CommandMap[commandName] = getattr(modules["commands."+commandName], className)
-                    className = command.capitalize()
+                debug("Reloaded command: %s" % commandName)
-                    __import__("commands.%s" % command)
+                return "RELOAD"
-                    eval("commands.%s.%s(func)" % (command, className))
+            module = __import__('commands.%s' % commandName)
+            CommandMap[commandName] = getattr(getattr(module, commandName), className)
+            debug("Registered command: %s" % commandName)
             return True
+
         except Exception as err:
             return err
+    return False