connection: reimplement timeout logic and redefine pings as a keep-alive feature

- Previous implementation was not able to import transactions with many small
  objects, the client for faster to send a store request than to process its
  answer. If X is the difference of time for these 2 operations, the maximum
  number of objects a transaction could contain was CRITICAL_TIMEOUT / X.
  And HasLock feature can't act as a workaround because it is not working yet.
- Change API of 'on_timeout', which currently only used by HasLock.
- Stop pinging when we wait for an answer. This wastes resources and would
  never recover any bad state.
- Make client connections send pings when they are idle instead.
  This implements keep-alive feature for high availability.
  Start with an non-configurable period of 60 seconds.
- Move processing of ping/pong to handlers.

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

TODO

@@ -20,7 +20,7 @@ RC  - Clarify cell state signification
 RC  - Review XXX in the code (CODE)
 RC  - Review TODO in the code (CODE)
 RC  - Review output of pylint (CODE)
-    - Keep-alive (HIGH AVAILABILITY)
+    - Keep-alive (HIGH AVAILABILITY) (implemented, to be reviewed and tested)
       Consider the need to implement a keep-alive system (packets sent
       automatically when there is no activity on the connection for a period
       of time).

neo/client/handlers/__init__.py

@@ -16,7 +16,7 @@
 # Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 
 from neo.lib.handler import EventHandler
-from neo.lib.protocol import ProtocolError
+from neo.lib.protocol import ProtocolError, Packets
 
 class BaseHandler(EventHandler):
     """Base class for client-side EventHandler implementations."""
@@ -37,10 +37,10 @@ class BaseHandler(EventHandler):
 
     def packetReceived(self, conn, packet):
         """Redirect all received packet to dispatcher thread."""
-        if packet.isResponse():
+        if packet.isResponse() and type(packet) is not Packets.Pong:
             if not self.dispatcher.dispatch(conn, packet.getId(), packet):
-                raise ProtocolError('Unexpected response packet from %r: %r',
-                        conn, packet)
+                raise ProtocolError('Unexpected response packet from %r: %r'
+                                    % (conn, packet))
         else:
             self.dispatch(conn, packet)
 

neo/lib/handler.py

@@ -121,6 +121,15 @@ class EventHandler(object):
 
     # Packet handlers.
 
+    def ping(self, conn):
+        if not conn.isAborted():
+            conn.answer(Packets.Pong())
+
+    def pong(self, conn):
+        # Ignore PONG packets. The only purpose of ping/pong packets is
+        # to test/maintain underlying connection.
+        pass
+
     def notify(self, conn, message):
         neo.lib.logging.info('notification from %r: %s', conn, message)