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

from fixbot import buffer, config

     8

     9

class ModuleInfo (object) :

    10

    """

    11

        Some info about a module

    12

    """

    13

    14

    # module's name

    15

    name = None

    16

    17

    # list of valid event types (strings)

    18

    event_types = None

    19

    20

    def __str__ (self) :

    22

    23

    def __repr__ (self) :

    25

    26

class Event (object) :

    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 (under 255 bytes in length!)

    34

    msg = None

    35

    36

    # timestamp as a datetime.datetime

    37

    when = None

    38

    39

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

    40

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

    41

    42

        self.module = module

    43

        self.type = type

    44

        self.msg = msg

    45

    46

        self.when = datetime.now()

    47

    48

    def __str__ (self) :

    49

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

    50

    51

    def __repr__ (self) :

    52

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

    53

    54

CLIENT_COMMANDS = [

    55

    "module_init",

    56

    "module_event",

    57

]

    58

    59

SERVER_COMMANDS = [

    60

    "module_ok",

    61

]

    62

    63

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

    64

    RECV_COMMANDS = CLIENT_COMMANDS

    65

    SEND_COMMANDS = SERVER_COMMANDS    

    66

    67

    VALID_STATES = [

    68

        "wait_init",

    69

        "wait_event"

    70

    ]

    71

    72

    # proto state

    73

    state = None

    74

    75

    # module info

    76

    module = None

    77

    78

    def _assert (self, condition, msg) :

    79

        if not condition :

    80

            self.transport.loseConnection()

    81

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

    82

    83

    def connectionMade (self) :

    84

        log.msg("Client connected")

    85

    86

    def connectionLost (self, reason) :

    87

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

    88

    89

        if self.module :

    90

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

    91

    92

    def on_module_init (self, i) :

    93

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

    94

    95

        peer_secret = i.readVarLen('B')

    96

    97

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

    98

    99

        m = ModuleInfo()

   100

   101

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

   102

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

   103

        m.addr = self.transport.getPeer()

   104

   105

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

   106

   107

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

   108

   109

        self.module = m

   110

   111

        o = self.startCommand('module_ok')

   112

   113

        self.send(o)

   114

   115

    def on_module_event (self, i) :

   116

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

   117

   118

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

   119

        event_msg = i.readVarLen('H')

   120

   121

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

   122

   123

        self.factory.nexus.handleEvent(e)

   124

   125

    def logPrefix (self) :

   126

        if self.module :

   127

            return str(self.module)

   128

        else :

   129

            return super(ServerProtocol, self).logPrefix()

   130

   131

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

   132

    RECV_COMMANDS = SERVER_COMMANDS

   133

    SEND_COMMANDS = CLIENT_COMMANDS

   134

   135

    def connectionMade (self) :

   136

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

   137

   138

        o = self.startCommand('module_init')

   139

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

   140

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

   141

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

   142

   143

        self.send(o)

   144

   145

    def sendEvent (self, event) :

   146

        o = self.startCommand('module_event')

   147

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

   148

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

   149

   150

        self.send(o)

   151

   152

    def on_module_ok (self, i) :

   153

        log.msg("Registration OK")

   154

   155

        self.factory.connected(self)

   156

   157

    def logPrefix (self) :

   159

   160

class Module (ModuleInfo, protocol.ClientFactory) :

   161

    protocol = ClientProtocol

   162

   163

    def __init__ (self, config) :

   164

        self.connection = None

   165

        self.secret = config['api-secret']

   166

   167

    def connected (self, connection) :

   168

        log.msg("Connected!")

   169

        self.connection = connection

   170

   171

        self.handleConnect()

   172

   173

    def disconnect (self) :

   174

        self.connection.transport.loseConnection()

   175

   176

    def sendEvent (self, type, msg) :

   177

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

   178

   179

    def buildEvent (self, type, msg) :

   180

        return Event(self, type, msg)

   181

   182

    def handleConnect (self) :

   183

        """

   184

            Do something

   185

        """

   186

   187

        pass

   188

   189

class ServerFactory (protocol.ServerFactory) :

   190

    protocol = ServerProtocol

   191

   192

    def __init__ (self, nexus, secret) :

   193

        self.nexus = nexus

   194

        self.secret = secret

   195

   196

class ClientOptions (config.ConfigOptions) :

   197

    optParameters = [

   198

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

   199

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

   200

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

   201

    ]

   202

   203

    optFlags = [

   204

   205

    ]

   206

   207

def makeService (module_class, config) :

   208

    s = service.MultiService()

   209

   210

    # build factory

   211

    factory = module_class(config)

   212

   213

    # the API client

   214

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

   215

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

   216

   217

    api_client.setServiceParent(s)

   218

   219

    return s

   220