1

from twisted.internet import protocol

     2

from twisted.application import service, internet

     3

from twisted.python import log

     4

     5

import datetime

     6

     7

class ModuleInfo (object) :

     8

    """

     9

        Nexus-side handle on a Module

    10

    """

    11

    12

    # module's name

    13

    name = None

    14

    15

    def __str__ (self) :

    17

    18

    def __repr__ (self) :

    19

        return "<module %s>" % (self.name, )

    20

    21

    22

class Event (object) :

    23

    """

    24

        An Event, sent by a Module to the Nexus, to be distributed further

    25

    """

    26

    27

    # the ModuleInfo object

    28

    module = None

    29

    30

    # the event type as a string

    31

    type = None

    32

    33

    # event message as a string (up to 64k, although that won't fit onto IRC..)

    34

    msg = None

    35

    36

    # timestamp as a datetime.datetime

    37

    when = None

    38

    39

    def __init__ (self, module, type, msg) :

    40

        self.module = module

    41

        self.type = type

    42

        self.msg = msg

    43

    44

        self.when = datetime.datetime.now()

    45

    46

    def __str__ (self) :

    47

        return "[%s] %s" % (self.type, self.msg)

    48

    49

    def __repr__ (self) :

    50

        return "%s @ %s" % (self.type, self.when)

    51

    52

    53

class Module (ModuleInfo, protocol.ClientFactory) :

    54

    """

    55

        Module core, handles the API connection state and processes all messages

    56

    """

    57

    58

    # our API connection to the Nexus

    59

    connection = None

    60

    61

    def __init__ (self, config, protocol) :

    62

        """

    63

            config      - configuration for connecting to nexus

    64

            protocol    - API client protocol to use for this factory

    65

        """

    66

    67

        self.protocol = protocol

    68

    69

        self.connection = None

    70

    71

        # XXX: legacy: self.secret = config['api-secret']

    72

    74

    def _onRegistered (self, connection) :

    75

        """

    76

            Connected to nexus and registered

    77

        """

    78

    79

        log.msg("Connected and registered")

    80

    81

        self.connection = connection

    84

        self.handleConnect()

    85

    88

    def disconnect (self) :

    89

        """

    90

            Disconnect from Nexus

    91

        """

    92

    93

        self.connection.transport.loseConnection()

    96

    def sendEvent (self, type, msg) :

    97

        """

    98

            Send event to nexus

    99

        """

   100

   101

        self.connection.sendEvent(Event(self, type, msg))

   102

   104

    def handleConnect (self) :

   105

        """

   106

            Do something once we are connected to nexus and registered

   107

        """

   108

   109

        pass

   110

   118

def makeService (module_class, config, protocol) :

   119

    s = service.MultiService()

   120

   121

    # build factory

   122

    factory = module_class(config, protocol)

   123

   124

    # the API client

   125

    log.msg("Connecting to API server on [%s:%d]" % (config['api-server'], config['api-port']))

   126

    api_client = internet.TCPClient(config['api-server'], config['api-port'], factory)

   127

   128

    api_client.setServiceParent(s)

   129

   130

    return s

   131