1

from twisted.application import internet, service

     2

from twisted.internet import protocol, reactor

     3

from twisted.python import log, usage

     4

from datetime import datetime

     5

import sys

     6

     8

     9

class ModuleInfo (object) :

    10

    """

    11

        Some info about a module

    12

    """

    13

    14

    # module's name

    15

    name = None

    16

    17

    # module's version, as a 16-bit integer

    18

    version = None

    19

    20

    # list of valid event types (strings)

    21

    event_types = None

    22

    23

    def __str__ (self) :

    24

        return "Module %s:%d" % (self.name, self.version)

    25

    26

    def __repr__ (self) :

    27

        return "<module %s:%d with events: %s>" % (self.name, self.version, ", ".join(self.event_types))

    28

    29

class Event (object) :

    30

    # the ModuleInfo object

    31

    module = None

    32

    33

    # the event type as a string

    34

    type = None

    35

    36

    # event message as a string (under 255 bytes in length!)

    37

    msg = None

    38

    39

    # timestamp as a datetime.datetime

    40

    when = None

    41

    42

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

    43

        assert type in module.event_types, "Invalid event-type %s for %r" % (type, self.module)

    44

    45

        self.module = module

    46

        self.type = type

    47

        self.msg = msg

    48

    49

        self.when = datetime.now()

    50

    51

    def __str__ (self) :

    52

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

    53

    54

    def __repr__ (self) :

    55

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

    56

    57

CLIENT_COMMANDS = [

    58

    "module_init",

    59

    "module_event",

    60

]

    61

    62

SERVER_COMMANDS = [

    63

    "module_ok",

    64

]

    65

    66

class ServerProtocol (buffer.StreamProtocol, protocol.Protocol) :

    67

    RECV_COMMANDS = CLIENT_COMMANDS

    68

    SEND_COMMANDS = SERVER_COMMANDS    

    69

    70

    VALID_STATES = [

    71

        "wait_init",

    72

        "wait_event"

    73

    ]

    74

    75

    # proto state

    76

    state = None

    77

    78

    # module info

    79

    module = None

    80

    81

    def _assert (self, condition, msg) :

    82

        if not condition :

    83

            self.transport.loseConnection()

    84

            log.err("assert failed in APIProtocol for %s: %s" % (self.module, msg))

    85

    86

    def connectionMade (self) :

    87

        log.msg("Client connected")

    88

    89

    def connectionLost (self, reason) :

    90

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

    91

    92

        if self.module :

    93

            self.factory.nexus.unregisterModule(self.module, reason.getErrorMessage())

    94

    95

    def on_module_init (self, i) :

    96

        self._assert(not self.module, "module_init with non-None self.module")

    97

    98

        peer_secret = i.readVarLen('B')

    99

   100

        self._assert(peer_secret == self.factory.secret, "Mismatching API secrets!")

   101

   102

        m = ModuleInfo()

   103

   104

        m.name = i.readVarLen('B')

   105

        m.version = i.readItem('H')

   106

   107

        m.event_types = list(buffer.readStringStream(i, 'B'))

   108

        m.addr = self.transport.getPeer()

   109

   110

        self.module_name = m.name

   111

   112

        log.msg("Got mod_init for %r" % m)

   113

   114

        self.factory.nexus.registerModule(m, self)

   115

   116

        self.module = m

   117

   118

        o = self.startCommand('module_ok')

   119

   120

        self.send(o)

   121

   122

    def on_module_event (self, i) :

   123

        self._assert(self.module, "module_event with None self.module!")

   124

   125

        event_type = i.readEnum(self.module.event_types)

   126

        event_msg = i.readVarLen('H')

   127

   128

        e = Event(self.module, event_type, event_msg)

   129

   130

#        log.msg("Got mod_event of %r" % (e))

   131

   132

        self.factory.nexus.handleEvent(e)

   133

   134

    def logPrefix (self) :

   135

        if self.module :

   136

            return str(self.module)

   137

        else :

   138

            return super(ServerProtocol, self).logPrefix()

   139

   140

class ClientProtocol (buffer.StreamProtocol, protocol.Protocol) :

   141

    RECV_COMMANDS = SERVER_COMMANDS

   142

    SEND_COMMANDS = CLIENT_COMMANDS

   143

   144

    def connectionMade (self) :

   145

        log.msg("Connected to API server, sending module init message")

   146

   147

        o = self.startCommand('module_init')

   148

        o.writeVarLen('B', self.factory.secret)

   149

        o.writeVarLen('B', self.factory.name)

   150

        o.writeItem("H", self.factory.version)

   151

        buffer.writeStringStream(o, 'B', self.factory.event_types)

   152

   153

        self.send(o)

   154

   155

    def sendEvent (self, event) :

   156

        o = self.startCommand('module_event')

   157

        o.writeEnum(self.factory.event_types, event.type)

   158

        o.writeVarLen('H', event.msg[:2**16])

   159

   160

        self.send(o)

   161

   162

    def on_module_ok (self, i) :

   163

        log.msg("Registration OK")

   164

   165

        self.factory.connected(self)

   166

   167

    def logPrefix (self) :

   168

        return "module %s:%d client" % (self.factory.name, self.factory.version)

   169

   170

class Module (ModuleInfo, protocol.ClientFactory) :

   171

    protocol = ClientProtocol

   172

   174

        self.connection = None

   176

   177

    def connected (self, connection) :

   178

        log.msg("Connected!")

   179

        self.connection = connection

   180

   181

        self.handleConnect()

   182

   183

    def disconnect (self) :

   184

        self.connection.transport.loseConnection()

   185

   186

    def sendEvent (self, type, msg) :

   187

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

   188

   189

    def buildEvent (self, type, msg) :

   190

        return Event(self, type, msg)

   191

   192

    def handleConnect (self) :

   193

        """

   194

            Do something

   195

        """

   196

   197

        pass

   198

   199

class ServerFactory (protocol.ServerFactory) :

   200

    protocol = ServerProtocol

   201

   202

    def __init__ (self, nexus, secret) :

   203

        self.nexus = nexus

   204

        self.secret = secret

   205

   207

    optParameters = [

   208

        (   "api-server",   "s",    "127.0.0.1",        "address of API server to connect to"           ),

   209

        (   "api-port",     "P",    34888,              "port of API server to connect to",     int     ),

   210

        (   "api-secret",   None,   None,               "secret key for API connections"                ),

   211

    ]

   212

   213

    optFlags = [

   214

   215

    ]

   216

   218

    s = service.MultiService()

   222

   223

    # the API client

   224

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

   226

   227

    api_client.setServiceParent(s)

   228

   229

    return s

   230