1

from twisted.words.protocols import irc

     2

from twisted.internet import protocol

     3

from twisted.python import log

     4

import traceback

     5

     6

import buffer

     7

     8

class ReplyException (Exception) :

     9

    def __init__ (self, reply) :

    10

        self.reply = reply

    11

    12

class Client (irc.IRCClient, object) :

    13

    """

    14

        Fixme IRC bot

    15

    """

    16

    17

    def __init__ (self) :

    18

        # can't config yet

    19

        pass

    20

    21

    # housekeeping

    22

    def connectionMade (self) :

    23

        self.nexus = self.factory.nexus

    24

    25

        self.nickname = self.factory.nickname

    26

        self.username = self.factory.username

    27

        self.channel = self.factory.channel

    28

    29

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

    30

    31

        super(Client, self).connectionMade()

    32

    33

    def connectionLost (self, reason) :

    34

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

    35

        super(Client, self).connectionLost(reason)

    36

    37

    def signedOn (self) :

    38

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

    39

        self.join(self.channel)

    40

    41

    def joined (self, channel) :

    42

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

    43

    44

        self.factory.connected(self)

    45

    46

    # our actual functionality

    47

    def send (self, msg) :

    48

        msg = str(msg)

    49

    50

        if len(msg) > 480 :

    51

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

    52

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

    53

    54

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

    55

    56

        self.notice(self.channel, msg)

    57

    58

    def sendEvent (self, event) :

    59

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

    60

    61

    def moduleConnected (self, module, addr) :

    62

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

    63

    64

    def moduleDisconnected (self, module, reason) :

    65

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

    66

    67

    class _noDefault : pass

    68

    69

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

    70

        if '.' in command :

    71

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

    72

        else :

    73

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

    74

    75

        if method :

    76

            return method

    77

        elif default is self._noDefault :

    78

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

    79

        else :

    80

            return default

    81

    82

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

    83

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

    84

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

    85

    86

            args = command.strip().split()

    87

            command = args.pop(0)

    88

    89

            try :

    90

                method = self._lookupCommand(command)

    91

    92

                reply = method(*args)

    93

    94

                if reply :

    95

                    self.send(reply)

    96

    97

            except ReplyException, e :

    98

                self.send(e.reply)

    99

   100

            except Exception, e :

   101

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

   102

                traceback.print_exc()

   103

   104

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

   105

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

   106

   107

        method = self._lookupCommand(cmd, None)

   108

   109

        if method :

   110

            return method.__doc__

   111

        else :

   112

            try :

   113

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

   114

   116

   117

            except KeyError :

   118

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

   119

   120

    def cmd_commands (self, module=None) :

   121

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

   122

   123

        if module :

   124

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

   125

        else :

   126

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

   127

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

   128

                for attr_name in Client.__dict__.iterkeys()

   129

                if attr_name.startswith("cmd_")

   130

            )

   131

   132

    def cmd_modules (self) :

   133

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

   134

   135

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

   136

            module.name

   137

            for module in self.nexus.getModules()

   138

        )   

   139

   140

class Factory (protocol.ClientFactory) :

   141

    protocol = Client

   142

   143

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

   144

        self.nexus = nexus

   145

   146

        # config

   147

        self.nickname = nickname

   148

        self.username = username

   149

        self.channel = channel

   150

   151

        # don't have a connection yet

   152

        self.connection = None

   153

   154

    def connected (self, connection) :

   155

        self.connection = connection

   156