Do not use hasattr, because hasattr drains exceptions.

git-svn-id: https://svn.erp5.org/repos/public/erp5/trunk@8156 20353a03-c40f-0410-a6d1-a30d3c3de9de

product/CMFActivity/Activity/SQLQueue.py

@@ -74,72 +74,76 @@ class SQLQueue(RAMQueue):
     activity_tool.SQLQueue_delMessage(uid = m.uid)
 
   def dequeueMessage(self, activity_tool, processing_node):
-    if hasattr(activity_tool,'SQLQueue_readMessageList'):
-      now_date = DateTime()
-      # Next processing date in case of error
-      next_processing_date = now_date + float(VALIDATION_ERROR_DELAY)/86400
-      priority = random.choice(priority_weight)
-      # Try to find a message at given priority level
-      result = activity_tool.SQLQueue_readMessage(processing_node=processing_node, priority=priority,
-                                                  to_date=now_date)
-      if len(result) == 0:
-        # If empty, take any message
-        result = activity_tool.SQLQueue_readMessage(processing_node=processing_node, priority=None,to_date=now_date)
-      if len(result) > 0:
-        line = result[0]
-        path = line.path
-        method_id = line.method_id
-        # Make sure message can not be processed anylonger
-        activity_tool.SQLQueue_processMessage(uid=line.uid)
-        get_transaction().commit() # Release locks before starting a potentially long calculation
-        m = self.loadMessage(line.message)
-        # Make sure object exists
-        validation_state = m.validate(self, activity_tool)
-        if validation_state is not VALID:
-          if validation_state in (EXCEPTION, INVALID_PATH):
-            if line.priority > MAX_PRIORITY:
-              # This is an error
-              activity_tool.SQLQueue_assignMessage(uid=line.uid, processing_node = VALIDATE_ERROR_STATE)
-                                                                                # Assign message back to 'error' state
-              #m.notifyUser(activity_tool)                                       # Notify Error
-              get_transaction().commit()                                        # and commit
-            else:
-              # Lower priority
-              activity_tool.SQLQueue_setPriority(uid=line.uid, priority = line.priority + 1)
-              get_transaction().commit() # Release locks before starting a potentially long calculation
+    readMessage = getattr(activity_tool, 'SQLQueue_readMessage', None)
+    if readMessage is None:
+      return 1
+
+    now_date = DateTime()
+    # Next processing date in case of error
+    next_processing_date = now_date + float(VALIDATION_ERROR_DELAY)/86400
+    priority = random.choice(priority_weight)
+    # Try to find a message at given priority level
+    result = readMessage(processing_node=processing_node, priority=priority,
+                         to_date=now_date)
+    if len(result) == 0:
+      # If empty, take any message
+      result = readMessage(processing_node=processing_node, priority=None,to_date=now_date)
+    if len(result) > 0:
+      line = result[0]
+      path = line.path
+      method_id = line.method_id
+      # Make sure message can not be processed anylonger
+      activity_tool.SQLQueue_processMessage(uid=line.uid)
+      get_transaction().commit() # Release locks before starting a potentially long calculation
+      m = self.loadMessage(line.message)
+      # Make sure object exists
+      validation_state = m.validate(self, activity_tool)
+      if validation_state is not VALID:
+        if validation_state in (EXCEPTION, INVALID_PATH):
+          if line.priority > MAX_PRIORITY:
+            # This is an error
+            activity_tool.SQLQueue_assignMessage(uid=line.uid, processing_node = VALIDATE_ERROR_STATE)
+                                                                              # Assign message back to 'error' state
+            #m.notifyUser(activity_tool)                                       # Notify Error
+            get_transaction().commit()                                        # and commit
           else:
-            # We do not lower priority for INVALID_ORDER errors but we do postpone execution
-            activity_tool.SQLQueue_setPriority(uid = line.uid, date = next_processing_date,
-                                                priority = line.priority)
+            # Lower priority
+            activity_tool.SQLQueue_setPriority(uid=line.uid, priority = line.priority + 1)
             get_transaction().commit() # Release locks before starting a potentially long calculation
         else:
-          # Try to invoke
-          activity_tool.invoke(m) # Try to invoke the message - what happens if read conflict error restarts transaction ?
-          if m.is_executed:                                          # Make sure message could be invoked
-            activity_tool.SQLQueue_delMessage(uid=line.uid)  # Delete it
-            get_transaction().commit()                                        # If successful, commit
+          # We do not lower priority for INVALID_ORDER errors but we do postpone execution
+          activity_tool.SQLQueue_setPriority(uid = line.uid, date = next_processing_date,
+                                              priority = line.priority)
+          get_transaction().commit() # Release locks before starting a potentially long calculation
+      else:
+        # Try to invoke
+        activity_tool.invoke(m) # Try to invoke the message - what happens if read conflict error restarts transaction ?
+        if m.is_executed:                                          # Make sure message could be invoked
+          activity_tool.SQLQueue_delMessage(uid=line.uid)  # Delete it
+          get_transaction().commit()                                        # If successful, commit
+        else:
+          get_transaction().abort()                                         # If not, abort transaction and start a new one
+          if line.priority > MAX_PRIORITY:
+            # This is an error
+            activity_tool.SQLQueue_assignMessage(uid=line.uid, processing_node = INVOKE_ERROR_STATE)
+                                                                              # Assign message back to 'error' state
+            m.notifyUser(activity_tool)                                       # Notify Error
+            get_transaction().commit()                                        # and commit
           else:
-            get_transaction().abort()                                         # If not, abort transaction and start a new one
-            if line.priority > MAX_PRIORITY:
-              # This is an error
-              activity_tool.SQLQueue_assignMessage(uid=line.uid, processing_node = INVOKE_ERROR_STATE)
-                                                                                # Assign message back to 'error' state
-              m.notifyUser(activity_tool)                                       # Notify Error
-              get_transaction().commit()                                        # and commit
-            else:
-              # Lower priority
-              activity_tool.SQLQueue_setPriority(uid=line.uid, date = next_processing_date,
-                                                 priority = line.priority + 1)
-              get_transaction().commit() # Release locks before starting a potentially long calculation
-        return 0
-      get_transaction().commit() # Release locks before starting a potentially long calculation
+            # Lower priority
+            activity_tool.SQLQueue_setPriority(uid=line.uid, date = next_processing_date,
+                                                priority = line.priority + 1)
+            get_transaction().commit() # Release locks before starting a potentially long calculation
+      return 0
+    get_transaction().commit() # Release locks before starting a potentially long calculation
     return 1
 
   def hasActivity(self, activity_tool, object, **kw):
-    if hasattr(activity_tool,'SQLQueue_readMessageList'):
+    hasMessage = getattr(activity_tool, 'SQLQueue_hasMessage', None)
+    if hasMessage is not None:
       if object is not None:
         my_object_path = '/'.join(object.getPhysicalPath())
-        result = activity_tool.SQLQueue_hasMessage(path=my_object_path, **kw)
+        result = hasMessage(path=my_object_path, **kw)
         if len(result) > 0:
           return result[0].message_count > 0
       else:
@@ -158,7 +162,8 @@ class SQLQueue(RAMQueue):
 
       NOTE: commiting is very likely nonsenses here. We should just avoid to flush as much as possible
     """
-    if hasattr(activity_tool,'SQLQueue_readMessageList'):
+    readMessageList = getattr(activity_tool, 'SQLQueue_readMessageList', None)
+    if readMessageList is not None:
       #return # Do nothing here to precent overlocking
       path = '/'.join(object_path)
       # Parse each message in registered
@@ -168,7 +173,7 @@ class SQLQueue(RAMQueue):
           activity_tool.unregisterMessage(self, m)
       # Parse each message in SQL queue
       #LOG('Flush', 0, str((path, invoke, method_id)))
-      result = activity_tool.SQLQueue_readMessageList(path=path, method_id=method_id,processing_node=None)
+      result = readMessageList(path=path, method_id=method_id,processing_node=None)
       #LOG('Flush', 0, str(len(result)))
       method_dict = {}
       for line in result:
@@ -202,8 +207,9 @@ class SQLQueue(RAMQueue):
 
   def getMessageList(self, activity_tool, processing_node=None,**kw):
     message_list = []
-    if hasattr(activity_tool,'SQLQueue_readMessageList'):
-      result = activity_tool.SQLQueue_readMessageList(path=None, method_id=None, processing_node=None)
+    readMessageList = getattr(activity_tool, 'SQLQueue_readMessageList', None)
+    if readMessageList is not None:
+      result = readMessageList(path=None, method_id=None, processing_node=None)
       for line in result:
         m = self.loadMessage(line.message)
         m.processing_node = line.processing_node
@@ -214,17 +220,19 @@ class SQLQueue(RAMQueue):
   def dumpMessageList(self, activity_tool):
     # Dump all messages in the table.
     message_list = []
-    if hasattr(activity_tool, 'SQLQueue_dumpMessageList'):
-      result = activity_tool.SQLQueue_dumpMessageList()
+    dumpMessageList = getattr(activity_tool, 'SQLQueue_dumpMessageList', None)
+    if dumpMessageList is not None:
+      result = dumpMessageList()
       for line in result:
         m = self.loadMessage(line.message, uid = line.uid)
         message_list.append(m)
     return message_list
-    
+
   def distribute(self, activity_tool, node_count):
     processing_node = 1
-    if hasattr(activity_tool,'SQLQueue_readMessageList'):
-      result = activity_tool.SQLQueue_readMessageList(path=None, method_id=None, processing_node = -1) # Only assign non assigned messages
+    readMessageList = getattr(activity_tool, 'SQLQueue_readMessageList', None)
+    if readMessageList is not None:
+      result = readMessageList(path=None, method_id=None, processing_node = -1) # Only assign non assigned messages
       #LOG('distribute count',0,str(len(result)) )
       #LOG('distribute count',0,str(map(lambda x:x.uid, result)))
       #get_transaction().commit() # Release locks before starting a potentially long calculation
@@ -296,7 +304,7 @@ class SQLQueue(RAMQueue):
     if result[0].uid_count > 0:
       return INVALID_ORDER
     return VALID
-    
+
   def _validate_after_tag(self, activity_tool, message, value):
     # Count number of occurances of tag
     if type(value) == type(''):
@@ -305,7 +313,7 @@ class SQLQueue(RAMQueue):
     if result[0].uid_count > 0:
       return INVALID_ORDER
     return VALID
-    
+
   def _validate_after_tag_and_method_id(self, activity_tool, message, value):
     # Count number of occurances of tag and method_id
     if (type(value) != type ( (0,) ) and type(value) != type([])) or len(value)<2:
@@ -321,7 +329,7 @@ class SQLQueue(RAMQueue):
     if result[0].uid_count > 0:
       return INVALID_ORDER
     return VALID
-  
+
   # Required for tests (time shift)
   def timeShift(self, activity_tool, delay, processing_node = None):
     """