1 """

     2     Irker protocol implementation.

     3 """

     4 

     5 from twisted.internet import protocol, defer

     6 from twisted.protocols import basic

     7 from twisted.python import log

     8 

     9 import json, urlparse

    10 

    11 class Irk (basic.LineOnlyReceiver) :

    12     """

    13         A connected Irk client.

    14     """

    15 

    16     delimiter = '\n'

    17     

    18     def connectionMade (self) :

    19         self.transport.logPrefix = self.logPrefix

    20         

    21         log.msg("connected", self)

    22     

    23     def connectionLost (self, reason) :

    24         log.err("connection lost", reason)

    25     

    26     def error (self, *args) :

    27         log.err(*args)

    28         self.transport.loseConnection()

    29 

    30     def lineReceived (self, line) :

    31         """

    32             JSON -> in

    33         """

    34 

    35         try :

    36             irk = json.loads(line)

    37 

    38         except ValueError as ex :

    39             # invalid

    40             return self.error(ex, line)

    41         

    42         # dispatch

    43         self.factory.irkReceived(irk).addErrback(self.error, line)

    44 

    45     def __str__ (self) :

    46         if not self.transport : return 'Irk'

    47 

    48         host = self.transport.getHost()

    49         peer = self.transport.getPeer()

    50 

    51         return "{host.host}:{host.port}:{peer.host}".format(host=host, peer=peer)

    52 

    53     logPrefix = __str__

    54 

    55 class IrkFactory (protocol.ServerFactory) :

    56     """

    57         Manage connected Irk clients.

    58     """

    59 

    60     MAXATTR = 16

    61 

    62     protocol = Irk

    63 

    64     def __init__ (self, irc) :

    65         self.irc = irc

    66     

    67     @defer.inlineCallbacks

    68     def irkReceived (self, irk) :

    69         """

    70             Deffered to handle lookup of target, and then sending message.

    71 

    72             Errbacks on failures.

    73         """

    74 

    75         log.msg(str(irk))

    76 

    77         if not 'to' in irk :

    78             raise ValueError("missing target: to")

    79         

    80         # MUST NOT be unicode

    81         # XXX: ValueError?

    82         url = urlparse.urlparse(str(irk.pop('to')))

    83         

    84         # connect, register, join

    85         target = yield self.irc.target(url)

    86         

    87         # dispatch attrs

    88         for attr, value in irk.iteritems() :

    89             if len(attr) >= self.MAXATTR or not attr.islower() :

    90                 raise ValueError("invalid attr: %s" % (attr, ))

    91     

    92             method = getattr(self, 'irk_' + attr, None)

    93 

    94             if not method :

    95                 raise ValueError("unknown attr: %s" % (attr, ))

    96 

    97             if value :

    98                 value = unicode(value)

    99             else :

   100                 value = None

   101 

   102             method(target, value)

   103     

   104     # XXX: explicitly enable?

   105     def irk_privmsg (self, target, value) :

   106         """

   107             Send PRIVMSG to target.

   108         """

   109         

   110         if not value :

   111             # legacy

   112             return

   113 

   114         target.privmsg(value)

   115 

   116     def irk_notice (self, target, value) :

   117         """

   118             Send NOTICE to target.

   119         """

   120 

   121         if not value :

   122             raise ValueError("empty notice")

   123 

   124         target.notice(value)

   125 

   126     # TODO: refcounting vs join!

   127     def irk_part (self, target, value) :

   128         """

   129             PART target.

   130         """

   131         

   132         # value is optional

   133         target.part(value)