monolith/modules/network.py

from twisted.internet import reactor
from twisted.internet.ssl import DefaultOpenSSLContextFactory

import main
from core.bot import IRCBotFactory
from modules import alias
from modules.chankeep import nukeNetwork
from modules.regproc import needToRegister
from utils.deliver_relay_commands import deliverRelayCommands
from utils.get import getRelay
from utils.logging.log import log


class Network:
    def __init__(self, net, host, port, security, auth):
        self.net = net
        self.host = host
        self.port = port
        self.security = security
        self.auth = auth

        self.last = 1
        self.relays = {}
        self.aliases = {}

    def add_relay(self, num=None):
        # Grrrrrrrrrr
        self.last = int(self.last)
        if not num:
            num = self.last
            self.last += 1
        elif num == self.last:
            self.last += 1
        registered = False
        if not needToRegister(self.net):
            registered = True
            # Don't need to register if it's been disabled in definitions,
            #  so we'll pretend we already did
        self.relays[num] = {
            "enabled": main.config["ConnectOnCreate"],
            "net": self.net,
            "id": num,
            "registered": registered,
        }
        password = alias.generate_password()
        if num not in main.alias.keys():
            main.alias[num] = alias.generate_alias()
            main.saveConf("alias")
        self.aliases[num] = {"password": password}
        # if main.config["ConnectOnCreate"]: -- Done in provision
        #    self.start_bot(num)
        return num, main.alias[num]["nick"]

    def enable_relay(self, num):
        """
        Enable a relay for this network.
        Send a command to ZNC to connect.
        """
        self.relays[num]["enabled"] = True
        user = main.alias[num]["nick"]
        commands = {"status": ["Connect"]}
        name = f"{self.net}{num}"
        deliverRelayCommands(num, commands, user=user + "/" + self.net)
        main.saveConf("network")
        if name not in main.IRCPool.keys():
            self.start_bot(num)

    def disable_relay(self, num):
        """
        Disable a relay for this network.
        Send a command to ZNC to disconnect.
        Stop trying to connect to the relay.
        """
        self.relays[num]["enabled"] = False
        user = main.alias[num]["nick"]
        # relay = main.network[spl[1]].relays[relayNum]
        commands = {"status": ["Disconnect"]}
        name = f"{self.net}{num}"
        deliverRelayCommands(num, commands, user=user + "/" + self.net)
        main.saveConf("network")
        if name in main.ReactorPool.keys():
            if name in main.FactoryPool.keys():
                main.FactoryPool[name].stopTrying()
            main.ReactorPool[name].disconnect()
            if name in main.IRCPool.keys():
                del main.IRCPool[name]
            del main.ReactorPool[name]
            del main.FactoryPool[name]

    def killAliases(self, aliasList):
        for i in aliasList:
            name = self.net + str(i)
            if name in main.ReactorPool.keys():
                if name in main.FactoryPool.keys():
                    main.FactoryPool[name].stopTrying()
                main.ReactorPool[name].disconnect()
                if name in main.IRCPool.keys():
                    del main.IRCPool[name]
                del main.ReactorPool[name]
                del main.FactoryPool[name]

    def delete_relay(self, id):
        del self.relays[id]
        del self.aliases[id]
        # del main.alias[id] - Aliases are global per num, so don't delete them!
        self.killAliases([id])

    def seppuku(self):
        # Removes all bots in preperation for deletion
        self.killAliases(self.relays.keys())
        nukeNetwork(self.net)

    def start_bot(self, num):
        # a single name is given to relays in the backend
        # e.g. freenode1 for the first relay on freenode network
        keyFN = main.certPath + main.config["Key"]
        certFN = main.certPath + main.config["Certificate"]
        contextFactory = DefaultOpenSSLContextFactory(
            keyFN.encode("utf-8", "replace"), certFN.encode("utf-8", "replace")
        )
        bot = IRCBotFactory(self.net, num)
        # host, port = self.relays[num]["host"], self.relays[num]["port"]
        host, port = getRelay(num)
        rct = reactor.connectSSL(host, port, bot, contextFactory)
        name = self.net + str(num)
        main.ReactorPool[name] = rct
        main.FactoryPool[name] = bot

        log("Started bot on relay %s on %s" % (num, self.host))

    def start_bots(self):
        for num in self.relays.keys():
            if self.relays[num]["enabled"]:
                self.start_bot(num)