handler.py 19.3 KB
Newer Older
Aurel's avatar
Aurel committed
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17
#
# Copyright (C) 2006-2009  Nexedi SA
# 
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
# 
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

18
import logging
Yoshinori Okuji's avatar
Yoshinori Okuji committed
19

20
from neo import protocol
21
from neo.protocol import PacketMalformedError, UnexpectedPacketError, \
22
        BrokenNodeDisallowedError, NotReadyError, ProtocolError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
23
from neo.connection import ServerConnection
Yoshinori Okuji's avatar
Yoshinori Okuji committed
24 25 26 27

from protocol import ERROR, REQUEST_NODE_IDENTIFICATION, ACCEPT_NODE_IDENTIFICATION, \
        PING, PONG, ASK_PRIMARY_MASTER, ANSWER_PRIMARY_MASTER, ANNOUNCE_PRIMARY_MASTER, \
        REELECT_PRIMARY_MASTER, NOTIFY_NODE_INFORMATION, START_OPERATION, \
28 29
        STOP_OPERATION, ASK_LAST_IDS, ANSWER_LAST_IDS, ASK_PARTITION_TABLE, \
        ANSWER_PARTITION_TABLE, SEND_PARTITION_TABLE, NOTIFY_PARTITION_CHANGES, \
30
        ASK_UNFINISHED_TRANSACTIONS, ANSWER_UNFINISHED_TRANSACTIONS, \
31
        ASK_OBJECT_PRESENT, ANSWER_OBJECT_PRESENT, \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
32 33 34
        DELETE_TRANSACTION, COMMIT_TRANSACTION, ASK_NEW_TID, ANSWER_NEW_TID, \
        FINISH_TRANSACTION, NOTIFY_TRANSACTION_FINISHED, LOCK_INFORMATION, \
        NOTIFY_INFORMATION_LOCKED, INVALIDATE_OBJECTS, UNLOCK_INFORMATION, \
35 36
        ASK_NEW_OIDS, ANSWER_NEW_OIDS, ASK_STORE_OBJECT, ANSWER_STORE_OBJECT, \
        ABORT_TRANSACTION, ASK_STORE_TRANSACTION, ANSWER_STORE_TRANSACTION, \
37
        ASK_OBJECT, ANSWER_OBJECT, ASK_TIDS, ANSWER_TIDS, ASK_TRANSACTION_INFORMATION, \
38
        ANSWER_TRANSACTION_INFORMATION, ASK_OBJECT_HISTORY, ANSWER_OBJECT_HISTORY, \
39
        ASK_OIDS, ANSWER_OIDS, ADD_PENDING_NODES, ANSWER_NEW_NODES, \
Yoshinori Okuji's avatar
Yoshinori Okuji committed
40 41
        NOT_READY_CODE, OID_NOT_FOUND_CODE, SERIAL_NOT_FOUND_CODE, TID_NOT_FOUND_CODE, \
        PROTOCOL_ERROR_CODE, TIMEOUT_ERROR_CODE, BROKEN_NODE_DISALLOWED_CODE, \
Aurel's avatar
Aurel committed
42
        INTERNAL_ERROR_CODE, ASK_PARTITION_LIST, ANSWER_PARTITION_LIST, ASK_NODE_LIST, \
43
        ANSWER_NODE_LIST, SET_NODE_STATE, ANSWER_NODE_STATE, SET_CLUSTER_STATE, \
44 45
        ASK_NODE_INFORMATION, ANSWER_NODE_INFORMATION, NO_ERROR_CODE, \
        ASK_CLUSTER_STATE, ANSWER_CLUSTER_STATE, NOTIFY_CLUSTER_INFORMATION
Yoshinori Okuji's avatar
Yoshinori Okuji committed
46

47

Yoshinori Okuji's avatar
Yoshinori Okuji committed
48 49
class EventHandler(object):
    """This class handles events."""
50 51
    def __init__(self, app):
        self.app = app
Yoshinori Okuji's avatar
Yoshinori Okuji committed
52 53 54 55 56
        self.initPacketDispatchTable()
        self.initErrorDispatchTable()

    def connectionStarted(self, conn):
        """Called when a connection is started."""
57
        logging.debug('connection started for %s:%d', *(conn.getAddress()))
Yoshinori Okuji's avatar
Yoshinori Okuji committed
58 59 60

    def connectionCompleted(self, conn):
        """Called when a connection is completed."""
61
        logging.debug('connection completed for %s:%d', *(conn.getAddress()))
Yoshinori Okuji's avatar
Yoshinori Okuji committed
62 63 64

    def connectionFailed(self, conn):
        """Called when a connection failed."""
65
        logging.debug('connection failed for %s:%d', *(conn.getAddress()))
Yoshinori Okuji's avatar
Yoshinori Okuji committed
66

67
    def connectionAccepted(self, conn, connector, addr):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
68
        """Called when a connection is accepted."""
69
        logging.debug('connection accepted from %s:%d', *addr)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
70
        new_conn = ServerConnection(conn.getEventManager(), conn.getHandler(),
71
                                    connector = connector, addr = addr)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
72 73 74 75 76
        # A request for a node identification should arrive.
        new_conn.expectMessage(timeout = 10, additional_timeout = 0)

    def timeoutExpired(self, conn):
        """Called when a timeout event occurs."""
77
        logging.debug('timeout expired for %s:%d', *(conn.getAddress()))
Yoshinori Okuji's avatar
Yoshinori Okuji committed
78 79 80

    def connectionClosed(self, conn):
        """Called when a connection is closed by the peer."""
81
        logging.debug('connection closed for %s:%d', *(conn.getAddress()))
Yoshinori Okuji's avatar
Yoshinori Okuji committed
82 83 84 85 86

    def packetReceived(self, conn, packet):
        """Called when a packet is received."""
        self.dispatch(conn, packet)

87
    # XXX: what's the purpose of this method ?
88 89 90 91
    def peerBroken(self, conn):
        """Called when a peer is broken."""
        logging.error('%s:%d is broken', *(conn.getAddress()))

92
    def packetMalformed(self, conn, packet, message='', *args):
Yoshinori Okuji's avatar
Yoshinori Okuji committed
93
        """Called when a packet is malformed."""
94
        args = (conn.getAddress()[0], conn.getAddress()[1], message)
95 96 97 98 99
        if packet is None:
            # if decoding fail, there's no packet instance 
            logging.info('malformed packet from %s:%d: %s', *args)
        else:
            logging.info('malformed packet %s from %s:%d: %s', packet.getType(), *args)
100
        response = protocol.protocolError(message)
101 102 103 104
        if packet is not None:
            conn.answer(response, packet)
        else:
            conn.notify(response)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
105 106 107
        conn.abort()
        self.peerBroken(conn)

Grégory Wisniewski's avatar
Grégory Wisniewski committed
108
    def unexpectedPacket(self, conn, packet, message=None):
109 110
        """Handle an unexpected packet."""
        if message is None:
111 112
            message = 'unexpected packet type %s in %s' % (packet.getType(),
                    self.__class__.__name__)
113
        else:
114 115
            message = 'unexpected packet: %s in %s' % (message,
                    self.__class__.__name__)
116
        logging.info('%s', message)
117
        conn.answer(protocol.protocolError(message), packet)
118 119
        conn.abort()
        self.peerBroken(conn)
120

121
    def brokenNodeDisallowedError(self, conn, packet, *args):
122
        """ Called when a broken node send packets """
123 124 125
        conn.answer(protocol.brokenNodeDisallowedError('go away'), packet)
        conn.abort()

126
    def notReadyError(self, conn, packet, *args):
127 128
        """ Called when the node is not ready """
        conn.answer(protocol.notReady('retry later'), packet)
129
        conn.abort()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
130

131
    def protocolError(self, conn, packet, message='', *args):
132 133 134 135
        """ Called for any other protocol error """
        conn.answer(protocol.protocolError(message), packet)
        conn.abort()

Yoshinori Okuji's avatar
Yoshinori Okuji committed
136 137 138 139
    def dispatch(self, conn, packet):
        """This is a helper method to handle various packet types."""
        t = packet.getType()
        try:
140 141 142 143
            try:
                method = self.packet_dispatch_table[t]
            except KeyError:
                raise UnexpectedPacketError('no handler found')
144
            args = packet.decode() or ()
Yoshinori Okuji's avatar
Yoshinori Okuji committed
145
            method(conn, packet, *args)
146 147 148 149 150 151 152 153 154 155
        except UnexpectedPacketError, e:
            self.unexpectedPacket(conn, packet, *e.args)
        except PacketMalformedError, e:
            self.packetMalformed(conn, packet, *e.args)
        except BrokenNodeDisallowedError, e:
            self.brokenNodeDisallowedError(conn, packet, *e.args)
        except NotReadyError, e:
            self.notReadyError(conn, packet, *e.args)
        except ProtocolError, e:
            self.protocolError(conn, packet, *e.args)
156

157 158 159 160 161 162
    def checkClusterName(self, name):
        # raise an exception if the fiven name mismatch the current cluster name
        if self.app.name != name:
            logging.error('reject an alien cluster')
            raise protocol.ProtocolError('invalid cluster name')

Yoshinori Okuji's avatar
Yoshinori Okuji committed
163 164 165 166 167 168 169
    # Packet handlers.

    def handleError(self, conn, packet, code, message):
        try:
            method = self.error_dispatch_table[code]
            method(conn, packet, message)
        except ValueError:
170
            raise UnexpectedPacketError(message)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
171 172 173

    def handleRequestNodeIdentification(self, conn, packet, node_type,
                                        uuid, ip_address, port, name):
174
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
175 176

    def handleAcceptNodeIdentification(self, conn, packet, node_type,
Aurel's avatar
Aurel committed
177
                                       uuid, ip_address, port,
178
                                       num_partitions, num_replicas, your_uuid):
179
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
180 181 182

    def handlePing(self, conn, packet):
        logging.info('got a ping packet; am I overloaded?')
183
        conn.answer(protocol.pong(), packet)
Yoshinori Okuji's avatar
Yoshinori Okuji committed
184 185 186 187

    def handlePong(self, conn, packet):
        pass

188
    def handleAskPrimaryMaster(self, conn, packet):
189
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
190

191 192
    def handleAnswerPrimaryMaster(self, conn, packet, primary_uuid,
                                  known_master_list):
193
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
194 195

    def handleAnnouncePrimaryMaster(self, conn, packet):
196
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
197 198

    def handleReelectPrimaryMaster(self, conn, packet):
199
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
200 201

    def handleNotifyNodeInformation(self, conn, packet, node_list):
202
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
203

204
    def handleAskLastIDs(self, conn, packet):
205
        raise UnexpectedPacketError
206 207

    def handleAnswerLastIDs(self, conn, packet, loid, ltid, lptid):
208
        raise UnexpectedPacketError
209 210

    def handleAskPartitionTable(self, conn, packet, offset_list):
211
        raise UnexpectedPacketError
212

213
    def handleAnswerPartitionTable(self, conn, packet, ptid, row_list):
214
        raise UnexpectedPacketError
215

216
    def handleSendPartitionTable(self, conn, packet, ptid, row_list):
217
        raise UnexpectedPacketError
218

219
    def handleNotifyPartitionChanges(self, conn, packet, ptid, cell_list):
220
        raise UnexpectedPacketError
221 222

    def handleStartOperation(self, conn, packet):
223
        raise UnexpectedPacketError
224 225

    def handleStopOperation(self, conn, packet):
226
        raise UnexpectedPacketError
227

228
    def handleAskUnfinishedTransactions(self, conn, packet):
229
        raise UnexpectedPacketError
230 231

    def handleAnswerUnfinishedTransactions(self, conn, packet, tid_list):
232
        raise UnexpectedPacketError
233 234

    def handleAskObjectPresent(self, conn, packet, oid, tid):
235
        raise UnexpectedPacketError
236 237

    def handleAnswerObjectPresent(self, conn, packet, oid, tid):
238
        raise UnexpectedPacketError
239 240

    def handleDeleteTransaction(self, conn, packet, tid):
241
        raise UnexpectedPacketError
242 243

    def handleCommitTransaction(self, conn, packet, tid):
244
        raise UnexpectedPacketError
245

Yoshinori Okuji's avatar
Yoshinori Okuji committed
246
    def handleAskNewTID(self, conn, packet):
247
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
248 249

    def handleAnswerNewTID(self, conn, packet, tid):
250
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
251

Grégory Wisniewski's avatar
Grégory Wisniewski committed
252
    def handleAskNewOIDs(self, conn, packet, num_oids):
253
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
254

Grégory Wisniewski's avatar
Grégory Wisniewski committed
255
    def handleAnswerNewOIDs(self, conn, packet, num_oids):
256
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
257

Yoshinori Okuji's avatar
Yoshinori Okuji committed
258
    def handleFinishTransaction(self, conn, packet, oid_list, tid):
259
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
260 261

    def handleNotifyTransactionFinished(self, conn, packet, tid):
262
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
263 264

    def handleLockInformation(self, conn, packet, tid):
265
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
266 267

    def handleNotifyInformationLocked(self, conn, packet, tid):
268
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
269

270
    def handleInvalidateObjects(self, conn, packet, oid_list, tid):
271
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
272 273

    def handleUnlockInformation(self, conn, packet, tid):
274
        raise UnexpectedPacketError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
275

276
    def handleAskStoreObject(self, conn, packet, oid, serial,
277
                             compression, checksum, data, tid):
278
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
279 280

    def handleAnswerStoreObject(self, conn, packet, status, oid):
281
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
282 283

    def handleAbortTransaction(self, conn, packet, tid):
284
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
285 286 287

    def handleAskStoreTransaction(self, conn, packet, tid, user, desc,
                                  ext, oid_list):
288
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
289 290

    def handleAnswerStoreTransaction(self, conn, packet, tid):
291
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
292

293
    def handleAskObject(self, conn, packet, oid, serial, tid):
294
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
295

296 297
    def handleAnswerObject(self, conn, packet, oid, serial_start,
                           serial_end, compression, checksum, data):
298
        raise UnexpectedPacketError
299

300
    def handleAskTIDs(self, conn, packet, first, last, partition):
301
        raise UnexpectedPacketError
302 303

    def handleAnswerTIDs(self, conn, packet, tid_list):
304
        raise UnexpectedPacketError
305 306

    def handleAskTransactionInformation(self, conn, packet, tid):
307
        raise UnexpectedPacketError
308

309 310
    def handleAnswerTransactionInformation(self, conn, packet, tid, 
                                           user, desc, ext, oid_list):
311
        raise UnexpectedPacketError
312

313
    def handleAskObjectHistory(self, conn, packet, oid, first, last):
314
        raise UnexpectedPacketError
315

316
    def handleAnswerObjectHistory(self, conn, packet, oid, history_list):
317
        raise UnexpectedPacketError
318

319
    def handleAskOIDs(self, conn, packet, first, last, partition):
320
        raise UnexpectedPacketError
321

322
    def handleAnswerOIDs(self, conn, packet, oid_list):
323
        raise UnexpectedPacketError
324

Aurel's avatar
Aurel committed
325
    def handleAskPartitionList(self, conn, packet, offset_list):
326
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
327 328

    def handleAnswerPartitionList(self, conn, packet, ptid, row_list):
329
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
330 331

    def handleAskNodeList(self, conn, packet, offset_list):
332
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
333 334

    def handleAnswerNodeList(self, conn, packet, ptid, row_list):
335
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
336

337
    def handleSetNodeState(self, conn, packet, uuid, state, modify_partition_table):
338
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
339 340

    def handleAnswerNodeState(self, conn, packet, uuid, state):
341
        raise UnexpectedPacketError
Aurel's avatar
Aurel committed
342

343 344 345 346 347 348
    def handleAddPendingNodes(self, conn, packet, uuid_list):
        raise UnexpectedPacketError

    def handleAnswerNewNodes(self, conn, packet, uuid_list):
        raise UnexpectedPacketError

349 350 351 352 353 354 355
    def handleAskNodeInformation(self, conn, packet):
        raise UnexpectedPacketError

    def handleAnswerNodeInformation(self, conn, packet, node_list):
        raise UnexpectedPacketError

    def handleAskClusterState(self, conn, packet):
356 357 358 359 360
        raise UnexpectedPacketError

    def handleAnswerClusterState(self, conn, packet, state):
        raise UnexpectedPacketError

361
    def handleSetClusterState(self, conn, packet, name, state):
362 363
        raise UnexpectedPacketError

364
    def handleNotifyClusterInformation(self, conn, packet, state):
365
        raise UnexpectedPacketError
366

Yoshinori Okuji's avatar
Yoshinori Okuji committed
367 368
    # Error packet handlers.

369
    # XXX: why answer a protocolError to another protocolError ?
370 371 372 373
    handleNotReady = unexpectedPacket
    handleOidNotFound = unexpectedPacket
    handleSerialNotFound = unexpectedPacket
    handleTidNotFound = unexpectedPacket
Yoshinori Okuji's avatar
Yoshinori Okuji committed
374 375 376 377 378 379 380 381 382 383 384 385 386 387

    def handleProtocolError(self, conn, packet, message):
        raise RuntimeError, 'protocol error: %s' % (message,)

    def handleTimeoutError(self, conn, packet, message):
        raise RuntimeError, 'timeout error: %s' % (message,)

    def handleBrokenNodeDisallowedError(self, conn, packet, message):
        raise RuntimeError, 'broken node disallowed error: %s' % (message,)

    def handleInternalError(self, conn, packet, message):
        self.peerBroken(conn)
        conn.close()

Aurel's avatar
Aurel committed
388 389 390
    def handleNoError(self, conn, packet, message):
        logging.info("no error message : %s" %(message))

Yoshinori Okuji's avatar
Yoshinori Okuji committed
391 392 393 394 395 396 397 398 399 400 401 402 403
    def initPacketDispatchTable(self):
        d = {}

        d[ERROR] = self.handleError
        d[REQUEST_NODE_IDENTIFICATION] = self.handleRequestNodeIdentification
        d[ACCEPT_NODE_IDENTIFICATION] = self.handleAcceptNodeIdentification
        d[PING] = self.handlePing
        d[PONG] = self.handlePong
        d[ASK_PRIMARY_MASTER] = self.handleAskPrimaryMaster
        d[ANSWER_PRIMARY_MASTER] = self.handleAnswerPrimaryMaster
        d[ANNOUNCE_PRIMARY_MASTER] = self.handleAnnouncePrimaryMaster
        d[REELECT_PRIMARY_MASTER] = self.handleReelectPrimaryMaster
        d[NOTIFY_NODE_INFORMATION] = self.handleNotifyNodeInformation
404 405 406 407 408 409 410 411
        d[ASK_LAST_IDS] = self.handleAskLastIDs
        d[ANSWER_LAST_IDS] = self.handleAnswerLastIDs
        d[ASK_PARTITION_TABLE] = self.handleAskPartitionTable
        d[ANSWER_PARTITION_TABLE] = self.handleAnswerPartitionTable
        d[SEND_PARTITION_TABLE] = self.handleSendPartitionTable
        d[NOTIFY_PARTITION_CHANGES] = self.handleNotifyPartitionChanges
        d[START_OPERATION] = self.handleStartOperation
        d[STOP_OPERATION] = self.handleStopOperation
412 413 414 415 416 417
        d[ASK_UNFINISHED_TRANSACTIONS] = self.handleAskUnfinishedTransactions
        d[ANSWER_UNFINISHED_TRANSACTIONS] = self.handleAnswerUnfinishedTransactions
        d[ASK_OBJECT_PRESENT] = self.handleAskObjectPresent
        d[ANSWER_OBJECT_PRESENT] = self.handleAnswerObjectPresent
        d[DELETE_TRANSACTION] = self.handleDeleteTransaction
        d[COMMIT_TRANSACTION] = self.handleCommitTransaction
Yoshinori Okuji's avatar
Yoshinori Okuji committed
418 419 420 421 422 423 424 425
        d[ASK_NEW_TID] = self.handleAskNewTID
        d[ANSWER_NEW_TID] = self.handleAnswerNewTID
        d[FINISH_TRANSACTION] = self.handleFinishTransaction
        d[NOTIFY_TRANSACTION_FINISHED] = self.handleNotifyTransactionFinished
        d[LOCK_INFORMATION] = self.handleLockInformation
        d[NOTIFY_INFORMATION_LOCKED] = self.handleNotifyInformationLocked
        d[INVALIDATE_OBJECTS] = self.handleInvalidateObjects
        d[UNLOCK_INFORMATION] = self.handleUnlockInformation
426 427
        d[ASK_NEW_OIDS] = self.handleAskNewOIDs
        d[ANSWER_NEW_OIDS] = self.handleAnswerNewOIDs
428 429
        d[ASK_STORE_OBJECT] = self.handleAskStoreObject
        d[ANSWER_STORE_OBJECT] = self.handleAnswerStoreObject
430
        d[ABORT_TRANSACTION] = self.handleAbortTransaction
431 432
        d[ASK_STORE_TRANSACTION] = self.handleAskStoreTransaction
        d[ANSWER_STORE_TRANSACTION] = self.handleAnswerStoreTransaction
433 434
        d[ASK_OBJECT] = self.handleAskObject
        d[ANSWER_OBJECT] = self.handleAnswerObject
435 436 437 438 439 440
        d[ASK_TIDS] = self.handleAskTIDs
        d[ANSWER_TIDS] = self.handleAnswerTIDs
        d[ASK_TRANSACTION_INFORMATION] = self.handleAskTransactionInformation
        d[ANSWER_TRANSACTION_INFORMATION] = self.handleAnswerTransactionInformation
        d[ASK_OBJECT_HISTORY] = self.handleAskObjectHistory
        d[ANSWER_OBJECT_HISTORY] = self.handleAnswerObjectHistory
441 442
        d[ASK_OIDS] = self.handleAskOIDs
        d[ANSWER_OIDS] = self.handleAnswerOIDs
Aurel's avatar
Aurel committed
443 444 445 446 447 448
        d[ASK_PARTITION_LIST] = self.handleAskPartitionList
        d[ANSWER_PARTITION_LIST] = self.handleAnswerPartitionList
        d[ASK_NODE_LIST] = self.handleAskNodeList
        d[ANSWER_NODE_LIST] = self.handleAnswerNodeList
        d[SET_NODE_STATE] = self.handleSetNodeState
        d[ANSWER_NODE_STATE] = self.handleAnswerNodeState
449
        d[SET_CLUSTER_STATE] = self.handleSetClusterState
450 451
        d[ADD_PENDING_NODES] = self.handleAddPendingNodes
        d[ANSWER_NEW_NODES] = self.handleAnswerNewNodes
452 453
        d[ASK_NODE_INFORMATION] = self.handleAskNodeInformation
        d[ANSWER_NODE_INFORMATION] = self.handleAnswerNodeInformation
454 455 456
        d[ASK_CLUSTER_STATE] = self.handleAskClusterState
        d[ANSWER_CLUSTER_STATE] = self.handleAnswerClusterState
        d[NOTIFY_CLUSTER_INFORMATION] = self.handleNotifyClusterInformation
457

Yoshinori Okuji's avatar
Yoshinori Okuji committed
458 459 460 461
        self.packet_dispatch_table = d

    def initErrorDispatchTable(self):
        d = {}
Aurel's avatar
Aurel committed
462
        d[NO_ERROR_CODE] = self.handleNoError
Yoshinori Okuji's avatar
Yoshinori Okuji committed
463 464 465 466 467 468 469 470 471 472
        d[NOT_READY_CODE] = self.handleNotReady
        d[OID_NOT_FOUND_CODE] = self.handleOidNotFound
        d[SERIAL_NOT_FOUND_CODE] = self.handleSerialNotFound
        d[TID_NOT_FOUND_CODE] = self.handleTidNotFound
        d[PROTOCOL_ERROR_CODE] = self.handleProtocolError
        d[TIMEOUT_ERROR_CODE] = self.handleTimeoutError
        d[BROKEN_NODE_DISALLOWED_CODE] = self.handleBrokenNodeDisallowedError
        d[INTERNAL_ERROR_CODE] = self.handleInternalError

        self.error_dispatch_table = d