redefine handler

merge loadBefore with other load in client part
first version for undo method


git-svn-id: https://svn.erp5.org/repos/neo/branches/prototype3@62 71dcc9de-d417-0410-9af5-da40c76e7ee4

neo/client/master.py → neo/client/handler.py

@@ -7,7 +7,10 @@ from neo.protocol import Packet, MASTER_NODE_TYPE, STORAGE_NODE_TYPE, CLIENT_NOD
 from neo.node import MasterNode, StorageNode, ClientNode
 from neo.pt import PartitionTable
 
-class MasterEventHandler(EventHandler):
+from ZODB.TimeStamp import TimeStamp
+from ZODB.utils import p64
+
+class ClientEventHandler(EventHandler):
     """This class deals with events for a master."""
 
     def __init__(self, app):
@@ -27,17 +30,16 @@ class MasterEventHandler(EventHandler):
         if isinstance(conn, ClientConnection):
             app = self.app
             node = app.nm.getNodeByServer(conn.getAddress())
-            if node_type != MASTER_NODE_TYPE:
-                # The peer is not a master node!
-                logging.error('%s:%d is not a master node', ip_address, port)
-                app.nm.remove(node)
+            # It can be eiter a master node or a storage node
+            if node_type == CLIENT_NODE_TYPE:
                 conn.close()
                 return
             if conn.getAddress() != (ip_address, port):
                 # The server address is different! Then why was
                 # the connection successful?
                 logging.error('%s:%d is waiting for %s:%d',
-                              conn.getAddress()[0], conn.getAddress()[1], ip_address, port)
+                              conn.getAddress()[0], conn.getAddress()[1],
+                              ip_address, port)
                 app.nm.remove(node)
                 conn.close()
                 return
@@ -45,6 +47,7 @@ class MasterEventHandler(EventHandler):
             conn.setUUID(uuid)
             node.setUUID(uuid)
 
+            if node_type == MASTER_NODE_TYPE:
                 # Create partition table if necessary
                 if app.pt is None:
                     app.pt = PartitionTable(num_partitions, num_replicas)
@@ -56,9 +59,20 @@ class MasterEventHandler(EventHandler):
         else:
             self.handleUnexpectedPacket(conn, packet)
 
+
+    # Master node handler
     def handleAnswerPrimaryMaster(self, conn, packet, primary_uuid, known_master_list):
         if isinstance(conn, ClientConnection):
+            uuid = conn.getUUID()
+            if uuid is None:
+                self.handleUnexpectedPacket(conn, packet)
+                return
+
             app = self.app
+            node = app.nm.getNodeByUUID(uuid)
+            # This must be sent only by primary master node
+            if not isinstance(node, MasterNode):
+                return
             # Register new master nodes.
             for ip_address, port, uuid in known_master_list:
                 addr = (ip_address, port)
@@ -91,16 +105,41 @@ class MasterEventHandler(EventHandler):
         else:
             self.handleUnexpectedPacket(conn, packet)
 
-    def handleSendPartitionTable(self, conn, packet, row_list):
+    def handleSendPartitionTable(self, conn, packet, ptid, row_list):
         if isinstance(conn, ClientConnection):
+            uuid = conn.getUUID()
+            if uuid is None:
+                self.handleUnexpectedPacket(conn, packet)
+                return
+
             app = self.app
+            node = app.nm.getNodeByUUID(uuid)
+            # This must be sent only by primary master node
+            if not isinstance(node, MasterNode) \
+                   or app.primary_master_node is None \
+                   or app.primary_master_node.getUUID() != uuid:
+                return
+
             for offset, node in row_list:
                 app.pt.setRow(offset, row)
         else:
             self.handleUnexpectedPacket(conn, packet)
 
     def handleNotifyNodeInformation(self, conn, packet, node_list):
+        if isinstance(conn, ClientConnection):
+            uuid = conn.getUUID()
+            if uuid is None:
+                self.handleUnexpectedPacket(conn, packet)
+                return
+
             app = self.app
+            node = app.nm.getNodeByUUID(uuid)
+            # This must be sent only by primary master node
+            if not isinstance(node, MasterNode) \
+                   or app.primary_master_node is None \
+                   or app.primary_master_node.getUUID() != uuid:
+                return
+
             for node_type, ip_address, port, uuid, state in node_list:
                 # Register new nodes.
                 addr = (ip_address, port)
@@ -112,23 +151,45 @@ class MasterEventHandler(EventHandler):
                     if n is None:
                         if node_type == MASTER_NODE:
                             n = MasterNode(server = addr)
+                            if uuid != INVALID_UUID:
+                                # If I don't know the UUID yet, believe what the peer
+                                # told me at the moment.
+                                if n.getUUID() is None:
+                                    n.setUUID(uuid)
                         elif node_typ == STORAGE_NODE:
+                            if uuid == INVALID_UUID:
+                                # No interest.
+                                continue
                             n = StorageNode(server = addr)
                         elif node_typ == CLIENT_NODE:
+                            if uuid == INVALID_UUID:
+                                # No interest.
+                                continue
                             n = ClientNode(server = addr)
                         else:
                             continue
                         app.app.nm.add(n)
+                    n.setState(state)
 
-                if uuid != INVALID_UUID:
-                    # If I don't know the UUID yet, believe what the peer
-                    # told me at the moment.
-                    if n.getUUID() is None:
-                        n.setUUID(uuid)
+        else:
+            self.handleUnexpectedPacket(conn, packet)
 
-    def handleNotifyPartitionChanges(self, conn, packet, cell_list):
+    def handleNotifyPartitionChanges(self, conn, packet, ptid, cell_list):
         if isinstance(conn, ClientConnection):
             app = self.app
+            uuid = conn.getUUID()
+            if uuid is None:
+                self.handleUnexpectedPacket(conn, packet)
+                return
+
+            app = self.app
+            node = app.nm.getNodeByUUID(uuid)
+            # This must be sent only by primary master node
+            if not isinstance(node, MasterNode) \
+                   or app.primary_master_node is None \
+                   or app.primary_master_node.getUUID() != uuid:
+                return
+
             for cell in cell_list:
                 app.pt.addNode(cell)
         else:
@@ -145,8 +206,8 @@ class MasterEventHandler(EventHandler):
         if isinstance(conn, ClientConnection):
             app = self.app
             if tid != app.tid:
-                # what's this ?
-                raise 
+                # What's this ?
+                raise NEOStorageError
             else:
                 app.txn_finished = 1
         else:
@@ -155,10 +216,60 @@ class MasterEventHandler(EventHandler):
     def handleInvalidateObjects(self, conn, packet, oid_list):
         raise NotImplementedError('this method must be overridden')
 
-    def handleAnswerNewOIDList(self, conn, packet, oid_list):
+    def handleAnswerNewOIDs(self, conn, packet, oid_list):
         if isinstance(conn, ClientConnection):
             app = self.app
             app.new_oid_list = oid_list
             app.new_oid_list.reverse()
         else:
             self.handleUnexpectedPacket(conn, packet)
+
+    # Storage node handler
+    def handleAnwserObjectByOID(self, oid, start_serial, end_serial, compression,
+                                checksum, data):
+        if isinstance(conn, ClientConnection):
+            app = self.app
+            app.loaded_object = (oid, start_serial, end_serial, compression,
+                                 checksum, data)
+        else:
+            self.handleUnexpectedPacket(conn, packet)
+
+    def handleAnswerStoreObject(self, conflicting, oid, serial):
+        if isinstance(conn, ClientConnection):
+            app = self.app
+            if conflicting == '1':
+                app.object_stored = -1
+            else:
+                app.object_stored = oid, serial
+        else:
+            self.handleUnexpectedPacket(conn, packet)
+
+    def handleAnswerStoreTransaction(self, tid):
+        if isinstance(conn, ClientConnection):
+            app = self.app
+            app.txn_stored = 1
+        else:
+            self.handleUnexpectedPacket(conn, packet)
+
+    def handleAnswerTransactionInformation(self, tid, user, desc, oid_list):
+        if isinstance(conn, ClientConnection):
+            app = self.app
+            # transaction information are returned as a dict
+            info = {}
+            info['time'] = TimeStamp(p64(long(tid))).timeTime()
+            info['user_name'] = user
+            info['description'] = desc
+            info['id'] = p64(long(tid))
+            info['oids'] = oid_list
+            app.txn_info = info
+        else:
+            self.handleUnexpectedPacket(conn, packet)
+
+    def handleAnswerObjectHistory(self, oid, history_list):
+        if isinstance(conn, ClientConnection):
+            app = self.app
+            # history_list is a list of tuple (serial, size)
+            self.history = oid, history_list
+        else:
+            self.handleUnexpectedPacket(conn, packet)
+