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

     7

import buffer

     8

     9

from api_secret import secret

    10

    11

class ModuleInfo (object) :

    12

    """

    13

        Some info about a module

    14

    """

    15

    16

    # module's name

    17

    name = None

    18

    19

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

    20

    version = None

    21

    22

    # list of valid event types (strings)

    23

    event_types = None

    24

    25

    def __str__ (self) :

    26

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

    27

    28

    def __repr__ (self) :

    29

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

    30

    31

class Event (object) :

    32

    # the ModuleInfo object

    33

    module = None

    34

    35

    # the event type as a string

    36

    type = None

    37

    38

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

    39

    msg = None

    40

    41

    # timestamp as a datetime.datetime

    42

    when = None

    43

    44

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

    45

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

    46

    47

        self.module = module

    48

        self.type = type

    49

        self.msg = msg

    50

    51

        self.when = datetime.now()

    52

    53

    def __str__ (self) :

    54

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

    55

    56

    def __repr__ (self) :

    57

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

    58

    59

CLIENT_COMMANDS = [

    60

    "module_init",

    61

    "module_event",

    62

]

    63

    64

SERVER_COMMANDS = [

    65

    "module_ok",

    66

]

    67

    68

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

    69

    RECV_COMMANDS = CLIENT_COMMANDS

    70

    SEND_COMMANDS = SERVER_COMMANDS    

    71

    72

    VALID_STATES = [

    73

        "wait_init",

    74

        "wait_event"

    75

    ]

    76

    77

    # proto state

    78

    state = None

    79

    80

    # module info

    81

    module = None

    82

    83

    def _assert (self, condition, msg) :

    84

        if not condition :

    85

            self.transport.loseConnection()

    86

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

    87

    88

    def connectionMade (self) :

    89

        log.msg("Client connected")

    90

    91

    def connectionLost (self, reason) :

    92

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

    93

    94

        if self.module :

    95

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

    96

    97

    def on_module_init (self, i) :

    98

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

    99

   100

        peer_secret = i.readVarLen('B')

   101

   102

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

   103

   104

        m = ModuleInfo()

   105

   106

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

   107

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

   108

   109

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

   110

        m.addr = self.transport.getPeer()

   111

   112

        self.module_name = m.name

   113

   114

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

   115

   116

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

   117

   118

        self.module = m

   119

   120

        o = self.startCommand('module_ok')

   121

   122

        self.send(o)

   123

   124

    def on_module_event (self, i) :

   125

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

   126

   127

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

   129

   130

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

   131

   132

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

   133

   134

        self.factory.nexus.handleEvent(e)

   135

   136

    def logPrefix (self) :

   137

        if self.module :

   138

            return str(self.module)

   139

        else :

   140

            return super(ServerProtocol, self).logPrefix()

   141

   142

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

   143

    RECV_COMMANDS = SERVER_COMMANDS

   144

    SEND_COMMANDS = CLIENT_COMMANDS

   145

   146

    def connectionMade (self) :

   147

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

   148

   149

        o = self.startCommand('module_init')

   150

        o.writeVarLen('B', secret)

   151

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

   152

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

   153

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

   154

   155

        self.send(o)

   156

   157

    def sendEvent (self, event) :

   158

        o = self.startCommand('module_event')

   159

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

   161

   162

        self.send(o)

   163

   164

    def on_module_ok (self, i) :

   165

        log.msg("Registration OK")

   166

   167

        self.factory.connected(self)

   168

   169

    def logPrefix (self) :

   170

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

   171

   172

class Module (ModuleInfo, protocol.ClientFactory) :

   173

    protocol = ClientProtocol

   174

   175

    def __init__ (self) :

   176

        self.connection = None

   177

   178

    def connected (self, connection) :

   179

        log.msg("Connected!")

   180

        self.connection = connection

   181

   182

        self.handleConnect()

   183

   184

    def disconnect (self) :

   185

        self.connection.transport.loseConnection()

   186

   187

    def sendEvent (self, type, msg) :

   188

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

   189

   190

    def buildEvent (self, type, msg) :

   191

        return Event(self, type, msg)

   192

   193

    def handleConnect (self) :

   194

        """

   195

            Do something

   196

        """

   197

   198

        pass

   199

   200

class ServerFactory (protocol.ServerFactory) :

   201

    protocol = ServerProtocol

   202

   203

    def __init__ (self, nexus) :

   204

        self.nexus = nexus

   205

   206

class ClientOptions (usage.Options) :

   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

    ]

   211

   212

    optFlags = [

   213

   214

    ]

   215

   216

def makeService (client_module_factory, config) :

   217

    s = service.MultiService()

   218

   219

    # the API client

   220

    module_factory = client_module_factory()

   221

   222

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

   223

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

   224

   225

    api_client.setServiceParent(s)

   226

   227

    return s

   228