1

from twisted.words.protocols import irc

     2

from twisted.internet import protocol

     3

from twisted.python import log

     4

import traceback

     5

     6

class ReplyException (Exception) :

     7

    def __init__ (self, reply) :

     8

        self.reply = reply

     9

    10

class Client (irc.IRCClient, object) :

    11

    """

    12

        Fixme IRC bot

    13

    """

    14

    15

    def __init__ (self) :

    16

        # can't config yet

    17

        pass

    18

    19

    # housekeeping

    20

    def connectionMade (self) :

    21

        self.nexus = self.factory.nexus

    22

    23

        self.nickname = self.factory.nickname

    24

        self.username = self.factory.username

    25

        self.channel = self.factory.channel

    26

    27

        log.msg("IRC Client connected, using username=%s, nickname=%s" % (self.username, self.nickname))

    28

    29

        super(Client, self).connectionMade()

    30

    31

    def connectionLost (self, reason) :

    32

        log.msg("Connection lost: %s" % reason)

    33

        super(Client, self).connectionLost(reason)

    34

    35

    def signedOn (self) :

    36

        log.msg("Signed on, joining channel %s" % self.channel)

    37

        self.join(self.channel)

    38

    39

    def joined (self, channel) :

    40

        log.msg("Joined channel %s" % channel)

    41

    42

        self.factory.connected(self)

    43

    44

    # our actual functionality

    45

    def send (self, msg) :

    46

        msg = str(msg)

    47

    48

        if len(msg) > 480 :

    49

            log.msg("truncating: %s" % msg)

    50

            msg = msg[:480] + "..."

    51

    52

        msg = msg.replace("\n", "\\n").replace("\r", "\\r").replace("\0", "\\0")

    53

    54

        self.notice(self.channel, msg)

    55

    56

    def sendEvent (self, event) :

    57

        self.send("[%s.%s] %s" % (event.module.name, event.type, event.msg))

    58

    59

    def moduleConnected (self, module, addr) :

    60

        self.send("{modules.%s} connected from %s" % (module.name, addr))

    61

    62

    def moduleDisconnected (self, module, reason) :

    63

        self.send("{modules.%s} disconnected: %s" % (module.name, reason))

    64

    65

    class _noDefault : pass

    66

    67

    def _lookupCommand (self, command, default=_noDefault) :

    68

        if '.' in command :

    69

            raise ReplyException("No support for module commands yet :P")

    70

        else :

    71

            method = getattr(self, "cmd_%s" % command, None)

    72

    73

        if method :

    74

            return method

    75

        elif default is self._noDefault :

    76

            raise ReplyException("No such command '%s'. See `help commands'" % command)

    77

        else :

    78

            return default

    79

    80

    def privmsg (self, user, channel, message) :

    81

        if message.lower().startswith(self.nickname.lower() + ':'):

    82

            me, command = message.split(":", 1)

    83

    84

            args = command.strip().split()

    85

            command = args.pop(0)

    86

    87

            try :

    88

                method = self._lookupCommand(command)

    89

    90

                reply = method(*args)

    91

    92

                if reply :

    93

                    self.send(reply)

    94

    95

            except ReplyException, e :

    96

                self.send(e.reply)

    97

    98

            except Exception, e :

    99

                self.send("Error: %s: %s" % (e.__class__.__name__, e))

   100

                traceback.print_exc()

   101

   102

    def cmd_help (self, cmd="help") :

   103

        """help <command|module> - Display help about the given command or module"""

   104

   105

        method = self._lookupCommand(cmd, None)

   106

   107

        if method :

   108

            return method.__doc__

   109

        else :

   110

            try :

   111

                module, addr = self.nexus.getModuleInfo(cmd)

   112

   113

                return "%s from %s. See `commands %s' for a list of commands" % (module.name, addr, module.name)

   114

   115

            except KeyError :

   116

                raise ReplyException("No command/module called `%s'. See `help commands'" % cmd)

   117

   118

    def cmd_commands (self, module=None) :

   119

        """commands [<module>] - Show primary commands, or commands in the given module (see `help modules')"""

   120

   121

        if module :

   122

            raise ReplyException("No support for module commands yet :P")

   123

        else :

   124

            return "Commands: %s" % ', '.join(

   125

                attr_name.split('_', 1)[1]

   126

                for attr_name in Client.__dict__.iterkeys()

   127

                if attr_name.startswith("cmd_")

   128

            )

   129

   130

    def cmd_modules (self) :

   131

        """modules - Show a list of connected modules"""

   132

   133

        return "Modules: %s" % ', '.join(

   134

            module.name

   135

            for module in self.nexus.getModules()

   136

        )   

   137

   138

class Factory (protocol.ClientFactory) :

   139

    protocol = Client

   140

   141

    def __init__ (self, nexus, nickname, username, channel) :

   142

        self.nexus = nexus

   143

   144

        # config

   145

        self.nickname = nickname

   146

        self.username = username

   147

        self.channel = channel

   148

   149

        # don't have a connection yet

   150

        self.connection = None

   151

   152

    def connected (self, connection) :

   153

        self.connection = connection

   154