diff --git a/product/CMFActivity/Activity/Queue.py b/product/CMFActivity/Activity/Queue.py index 1e0be03983e20dffcec3204a2482cbcbe0de2898..907f0c2d3f243b04ee36d38abdee9f2c25598c74 100644 --- a/product/CMFActivity/Activity/Queue.py +++ b/product/CMFActivity/Activity/Queue.py @@ -45,7 +45,7 @@ INVALID_ORDER = 2 MAX_PROCESSING_TIME = 900 # in seconds VALIDATION_ERROR_DELAY = 30 # in seconds -class Queue: +class Queue(object): """ Step 1: use lists @@ -101,10 +101,10 @@ class Queue: m.is_deleted = 1 def dequeueMessage(self, activity_tool, processing_node): - pass + raise NotImplementedError def distribute(self, activity_tool, node_count): - pass + raise NotImplementedError def validate(self, activity_tool, message, check_order_validation=1, **kw): """ diff --git a/product/CMFActivity/Activity/RAMDict.py b/product/CMFActivity/Activity/RAMDict.py deleted file mode 100644 index 2b5d1c769d6b5f41e664de66f1f97d2e294d571e..0000000000000000000000000000000000000000 --- a/product/CMFActivity/Activity/RAMDict.py +++ /dev/null @@ -1,179 +0,0 @@ -############################################################################## -# -# Copyright (c) 2002 Nexedi SARL and Contributors. All Rights Reserved. -# Jean-Paul Smets-Solanes <jp@nexedi.com> -# -# WARNING: This program as such is intended to be used by professional -# programmers who take the whole responsability of assessing all potential -# consequences resulting from its eventual inadequacies and bugs -# End users who are looking for a ready-to-use solution with commercial -# garantees and support are strongly adviced to contract a Free Software -# Service Company -# -# 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -# -############################################################################## - -from Products.CMFActivity.ActivityTool import registerActivity, MESSAGE_EXECUTED -from Products.CMFActivity.Errors import ActivityFlushError -from Queue import Queue, VALID - -from zLOG import LOG - -import transaction - -class RAMDict(Queue): - """ - A simple RAM based queue. It is not compatible with transactions which - means methods can be called before an object even exists or before - it is modified. This also means there is no garantee on any kind of sequenciality. - - Dictionnary is global. - """ - - def __init__(self): - Queue.__init__(self) - self.queue_dict = {} - - def getDict(self, activity_tool_path): - return self.queue_dict.setdefault(activity_tool_path, {}) - - def finishQueueMessage(self, activity_tool_path, m): - if m.is_registered: - self.getDict(activity_tool_path)[(tuple(m.object_path), m.method_id)] = m - - def finishDeleteMessage(self, activity_tool_path, message): - for key, m in self.getDict(activity_tool_path).items(): - if m.object_path == message.object_path and m.method_id == message.method_id: - del self.getDict(activity_tool_path)[(tuple(m.object_path), m.method_id)] - - def registerActivityBuffer(self, activity_buffer): - pass - - def generateMessageUID(self, m): - return (tuple(m.object_path), m.method_id) - - def isMessageRegistered(self, activity_buffer, activity_tool, m): - uid_set = activity_buffer.getUidSet(self) - return self.generateMessageUID(m) in uid_set - - def registerMessage(self, activity_buffer, activity_tool, m): - message_list = activity_buffer.getMessageList(self) - message_list.append(m) - uid_set = activity_buffer.getUidSet(self) - uid_set.add(self.generateMessageUID(m)) - m.is_registered = 1 - - def dequeueMessage(self, activity_tool, processing_node): - path = activity_tool.getPhysicalPath() - if len(self.getDict(path).keys()) is 0: - return 1 # Go to sleep - for key, m in self.getDict(path).items(): - if m.validate(self, activity_tool) is VALID: - activity_tool.invoke(m) - if m.getExecutionState() == MESSAGE_EXECUTED: - del self.getDict(path)[key] - transaction.commit() - return 0 - else: - # Start a new transaction and keep on to next message - transaction.commit() - return 1 - - def countMessage(self, activity_tool,path=None,method_id=None,**kw): - tool_path = activity_tool.getPhysicalPath() - count = 0 - for (key,m) in self.getDict(tool_path).items(): - add = 1 - if path is not None: - object_path = '/'.join(m.object_path) - if object_path != path: - add = 0 - if method_id is not None: - if m.method_id != method_id: - add = 0 - count += add - return count - - def hasActivity(self, activity_tool, object, **kw): - if object is not None: - object_path = object.getPhysicalPath() - else: - object_path = None - active_process = kw.get('active_process', None) - path = activity_tool.getPhysicalPath() - for m in self.getDict(path).values(): - # Filter active process and path if defined - if active_process is None or m.active_process == active_process: - if object_path is None or m.object_path == object_path: - return 1 - return 0 - - def flush(self, activity_tool, object_path, invoke=0, method_id=None, **kw): - path = '/'.join(object_path) - # LOG('Flush', 0, str((path, invoke, method_id))) - method_dict = {} - # Parse each message in registered - for m in activity_tool.getRegisteredMessageList(self): - if object_path == m.object_path and (method_id is None or method_id == m.method_id): - if not method_dict.has_key(m.method_id): - if invoke: - # First Validate - if m.validate(self, activity_tool) is VALID: - activity_tool.invoke(m) # Try to invoke the message - what happens if invoke calls flushActivity ?? - if m.getExecutionState() != MESSAGE_EXECUTED: # Make sure message could be invoked - # The message no longer exists - raise ActivityFlushError, ( - 'Could not evaluate %s on %s' % (method_id , path)) - else: - method_dict[m.method_id] = 1 - activity_tool.unregisterMessage(self, m) - else: - # The message no longer exists - raise ActivityFlushError, ( - 'The document %s does not exist' % path) - else: - method_dict[m.method_id] = 1 - activity_tool.unregisterMessage(self, m) - else: - method_dict[m.method_id] = 1 - activity_tool.unregisterMessage(self, m) - # Parse each message in RAM dict - path = activity_tool.getPhysicalPath() - for key, m in self.getDict(path).items(): - if object_path == m.object_path and (method_id is None or method_id == m.method_id): - if not method_dict.has_key(m.method_id): - LOG('CMFActivity RAMDict: ', 0, 'flushing object %s' % '/'.join(m.object_path)) - if invoke: - activity_tool.invoke(m) - if m.getExecutionState() == MESSAGE_EXECUTED: - method_dict[m.method_id] = 1 - self.deleteMessage(activity_tool, m) - else: - method_dict[m.method_id] = 1 - self.deleteMessage(activity_tool, m) - else: - self.deleteMessage(activity_tool, m) - - def getMessageList(self, activity_tool, processing_node=None,**kw): - new_queue = [] - path = activity_tool.getPhysicalPath() - for m in self.getDict(path).values(): - m.processing_node = 1 - m.priority = 0 - new_queue.append(m) - return new_queue - -registerActivity(RAMDict) diff --git a/product/CMFActivity/Activity/RAMQueue.py b/product/CMFActivity/Activity/RAMQueue.py deleted file mode 100644 index 793f3b945bdf461f6e0bcddd5b41c8b80079fc6c..0000000000000000000000000000000000000000 --- a/product/CMFActivity/Activity/RAMQueue.py +++ /dev/null @@ -1,144 +0,0 @@ -############################################################################## -# -# Copyright (c) 2002 Nexedi SARL and Contributors. All Rights Reserved. -# Jean-Paul Smets-Solanes <jp@nexedi.com> -# -# WARNING: This program as such is intended to be used by professional -# programmers who take the whole responsability of assessing all potential -# consequences resulting from its eventual inadequacies and bugs -# End users who are looking for a ready-to-use solution with commercial -# garantees and support are strongly adviced to contract a Free Software -# Service Company -# -# 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., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. -# -############################################################################## - -from Products.CMFActivity.ActivityTool import registerActivity, MESSAGE_EXECUTED -from Queue import Queue, VALID - -import transaction - -class RAMQueue(Queue): - """ - A simple RAM based queue - """ - def __init__(self): - Queue.__init__(self) - self.queue_dict = {} - self.last_uid = 0 - - def getQueue(self, activity_tool_path): - return self.queue_dict.setdefault(activity_tool_path, []) - - def finishQueueMessage(self, activity_tool_path, m): - if m.is_registered: - # XXX - Some lock is required on this section - self.last_uid = self.last_uid + 1 - m.uid = self.last_uid - self.getQueue(activity_tool_path).append(m) - - def finishDeleteMessage(self, activity_tool_path, m): - i = 0 - queue = self.getQueue(activity_tool_path) - for my_message in queue: - if my_message.uid == m.uid: - del queue[i] - return - i = i + 1 - - def dequeueMessage(self, activity_tool, processing_node): - path = activity_tool.getPhysicalPath() - for m in self.getQueue(path): - if m.validate(self, activity_tool) is not VALID: - self.deleteMessage(activity_tool, m) # Trash messages which are not validated (no error handling) - transaction.commit() # Start a new transaction - return 0 # Keep on ticking - activity_tool.invoke(m) - if m.getExecutionState() == MESSAGE_EXECUTED: - self.deleteMessage(activity_tool, m) # Trash messages which are not validated (no error handling) - transaction.commit() # Start a new transaction - return 0 # Keep on ticking - else: - # Start a new transaction and keep on to next message - transaction.commit() - return 1 # Go to sleep - - def countMessage(self, activity_tool,path=None,method_id=None,**kw): - tool_path = activity_tool.getPhysicalPath() - count = 0 - for m in self.getQueue(tool_path): - add = 1 - if path is not None: - object_path = '/'.join(m.object_path) - if object_path != path: - add = 0 - if method_id is not None: - if m.method_id != method_id: - add = 0 - count += add - return count - - def hasActivity(self, activity_tool, object, **kw): - if object is not None: - object_path = object.getPhysicalPath() - else: - object_path = None - active_process = kw.get('active_process', None) - path = activity_tool.getPhysicalPath() - for m in self.getQueue(path): - # Filter active process and path if defined - if active_process is None or m.active_process == active_process: - if object_path is None or m.object_path == object_path: - return 1 - return 0 - - def flush(self, activity_tool, object_path, invoke=0, method_id=None, **kw): - # Parse each message in registered - for m in activity_tool.getRegisteredMessageList(self): - if object_path == m.object_path and (method_id is None or method_id == m.method_id): - if m.validate(self, activity_tool) is not VALID: - activity_tool.unregisterMessage(self, m) # Trash messages which are not validated (no error handling) - else: - if invoke: - activity_tool.invoke(m) - if m.getExecutionState() == MESSAGE_EXECUTED: - activity_tool.unregisterMessage(self, m) - else: - activity_tool.unregisterMessage(self, m) - # Parse each message in queue - path = activity_tool.getPhysicalPath() - for m in self.getQueue(path): - if object_path == m.object_path and (method_id is None or method_id == m.method_id): - if m.validate(self, activity_tool) is not VALID: - self.deleteMessage(activity_tool, m) # Trash messages which are not validated (no error handling) - else: - if invoke: - activity_tool.invoke(m) - if m.getExecutionState() == MESSAGE_EXECUTED: - self.deleteMessage(activity_tool, m) # Only delete if no error happens - else: - self.deleteMessage(activity_tool, m) - - def getMessageList(self, activity_tool, processing_node=None,**kw): - new_queue = [] - path = activity_tool.getPhysicalPath() - for m in self.getQueue(path): - m.processing_node = 1 - m.priority = 0 - new_queue.append(m) - return new_queue - -registerActivity(RAMQueue) diff --git a/product/CMFActivity/Activity/SQLBase.py b/product/CMFActivity/Activity/SQLBase.py index cc3c5595e71674dba643b4644b8ef36ea1e79092..c45ae2b01c66633866909ec463bfe70ad7816e53 100644 --- a/product/CMFActivity/Activity/SQLBase.py +++ b/product/CMFActivity/Activity/SQLBase.py @@ -36,7 +36,7 @@ from Products.CMFActivity.ActiveObject import ( INVOKE_ERROR_STATE, VALIDATE_ERROR_STATE) from Products.CMFActivity.ActivityRuntimeEnvironment import ( ActivityRuntimeEnvironment, getTransactionalVariable) -from Queue import VALIDATION_ERROR_DELAY +from Queue import Queue, VALIDATION_ERROR_DELAY def sort_message_key(message): # same sort key as in SQL{Dict,Queue}_readMessageList @@ -44,7 +44,7 @@ def sort_message_key(message): _DequeueMessageException = Exception() -class SQLBase: +class SQLBase(Queue): """ Define a set of common methods for SQL-based storage of activities. """ diff --git a/product/CMFActivity/Activity/SQLDict.py b/product/CMFActivity/Activity/SQLDict.py index 28a62433215307ed081add9b85254c038a279fa5..f92703a99853afccfc90b05972befd754fdefc1b 100644 --- a/product/CMFActivity/Activity/SQLDict.py +++ b/product/CMFActivity/Activity/SQLDict.py @@ -28,7 +28,6 @@ from Products.CMFActivity.ActivityTool import registerActivity, MESSAGE_NOT_EXECUTED, MESSAGE_EXECUTED from Queue import VALID, INVALID_PATH -from RAMDict import RAMDict from Products.CMFActivity.Errors import ActivityFlushError import sys #from time import time @@ -45,7 +44,7 @@ READ_MESSAGE_LIMIT = 1000 MAX_MESSAGE_LIST_SIZE = 100 -class SQLDict(RAMDict, SQLBase): +class SQLDict(SQLBase): """ A simple OOBTree based queue. It should be compatible with transactions and provide sequentiality. Should not create conflict @@ -103,21 +102,19 @@ class SQLDict(RAMDict, SQLBase): if len(uid_list)>0: activity_tool.SQLBase_delMessage(table=self.sql_table, uid=uid_list) - def finishQueueMessage(self, activity_tool_path, m): - # Nothing to do in SQLDict. - pass - - def finishDeleteMessage(self, activity_tool_path, m): - # Nothing to do in SQLDict. - pass - - # Registration management - def registerActivityBuffer(self, activity_buffer): - pass - def generateMessageUID(self, m): return (tuple(m.object_path), m.method_id, m.activity_kw.get('tag'), m.activity_kw.get('group_id')) + def isMessageRegistered(self, activity_buffer, activity_tool, m): + return self.generateMessageUID(m) in activity_buffer.getUidSet(self) + + def registerMessage(self, activity_buffer, activity_tool, m): + message_list = activity_buffer.getMessageList(self) + message_list.append(m) + uid_set = activity_buffer.getUidSet(self) + uid_set.add(self.generateMessageUID(m)) + m.is_registered = 1 + def unregisterMessage(self, activity_buffer, activity_tool, m): m.is_registered = 0 # This prevents from inserting deleted messages into the queue class_name = self.__class__.__name__ @@ -158,8 +155,6 @@ class SQLDict(RAMDict, SQLBase): raise return uid_list - dequeueMessage = SQLBase.dequeueMessage - def hasActivity(self, activity_tool, object, method_id=None, only_valid=None, active_process_uid=None): hasMessage = getattr(activity_tool, 'SQLDict_hasMessage', None) if hasMessage is not None: @@ -244,8 +239,6 @@ class SQLDict(RAMDict, SQLBase): activity_tool.SQLBase_delMessage(table=self.sql_table, uid=[x.uid for x in uid_list]) - getMessageList = SQLBase.getMessageList - def dumpMessageList(self, activity_tool): # Dump all messages in the table. message_list = [] @@ -395,7 +388,7 @@ class SQLDict(RAMDict, SQLBase): def getPriority(self, activity_tool): method = activity_tool.SQLDict_getPriority - default = RAMDict.getPriority(self, activity_tool) + default = SQLBase.getPriority(self, activity_tool) return self._getPriority(activity_tool, method, default) registerActivity(SQLDict) diff --git a/product/CMFActivity/Activity/SQLQueue.py b/product/CMFActivity/Activity/SQLQueue.py index 0d9aa1a2ac63fe95bfafea8a22ffe7c4a674290c..00641d145ea8bf537db16858fc0c98ce7c64d0ce 100644 --- a/product/CMFActivity/Activity/SQLQueue.py +++ b/product/CMFActivity/Activity/SQLQueue.py @@ -27,7 +27,6 @@ ############################################################################## from Products.CMFActivity.ActivityTool import registerActivity, MESSAGE_NOT_EXECUTED, MESSAGE_EXECUTED -from RAMQueue import RAMQueue from Queue import VALID, INVALID_PATH from Products.CMFActivity.Errors import ActivityFlushError from ZODB.POSException import ConflictError @@ -45,7 +44,7 @@ READ_MESSAGE_LIMIT = 1000 MAX_MESSAGE_LIST_SIZE = 100 -class SQLQueue(RAMQueue, SQLBase): +class SQLQueue(SQLBase): """ A simple OOBTree based queue. It should be compatible with transactions and provide sequentiality. Should not create conflict @@ -94,14 +93,6 @@ class SQLQueue(RAMQueue, SQLBase): #LOG("prepareDeleteMessage", 0, str(m.__dict__)) activity_tool.SQLBase_delMessage(table=self.sql_table, uid=[m.uid]) - def finishQueueMessage(self, activity_tool_path, m): - # Nothing to do in SQLQueue. - pass - - def finishDeleteMessage(self, activity_tool_path, m): - # Nothing to do in SQLQueue. - pass - def getDuplicateMessageUidList(self, activity_tool, line, processing_node): """ Reserve unreserved messages matching given line. @@ -109,8 +100,6 @@ class SQLQueue(RAMQueue, SQLBase): """ return () - dequeueMessage = SQLBase.dequeueMessage - def hasActivity(self, activity_tool, object, method_id=None, only_valid=None, active_process_uid=None): hasMessage = getattr(activity_tool, 'SQLQueue_hasMessage', None) if hasMessage is not None: @@ -181,8 +170,6 @@ class SQLQueue(RAMQueue, SQLBase): activity_tool.SQLBase_delMessage(table=self.sql_table, uid=[line.uid for line in result]) - getMessageList = SQLBase.getMessageList - def countMessage(self, activity_tool, tag=None, path=None, method_id=None, message_uid=None, **kw): """Return the number of messages which match the given parameters. @@ -308,7 +295,7 @@ class SQLQueue(RAMQueue, SQLBase): def getPriority(self, activity_tool): method = activity_tool.SQLQueue_getPriority - default = RAMQueue.getPriority(self, activity_tool) + default = SQLBase.getPriority(self, activity_tool) return self._getPriority(activity_tool, method, default) registerActivity(SQLQueue) diff --git a/product/CMFActivity/ActivityTool.py b/product/CMFActivity/ActivityTool.py index 8c53281f57388a6bf942e6970724709c1e6405f7..30247db1d29b61f6a802920a4f76119144e5f10d 100644 --- a/product/CMFActivity/ActivityTool.py +++ b/product/CMFActivity/ActivityTool.py @@ -552,7 +552,7 @@ class ActivityTool (Folder, UniqueObject): def initialize(self): global is_initialized - from Activity import RAMQueue, RAMDict, SQLQueue, SQLDict + from Activity import SQLQueue, SQLDict # Initialize each queue for activity in activity_dict.itervalues(): activity.initialize(self) @@ -965,7 +965,7 @@ class ActivityTool (Folder, UniqueObject): # Loop as long as there are activities. Always process the queue with # "highest" priority. If several queues have same highest priority, do # not choose one that has just been processed. - # This algorithm is fair enough because we actually use only 2 queues. + # This algorithm is fair enough because we only have 2 queues. # Otherwise, a round-robin of highest-priority queues would be required. # XXX: We always finish by iterating over all queues, in case that # getPriority does not see messages dequeueMessage would process. @@ -974,7 +974,7 @@ class ActivityTool (Folder, UniqueObject): return activity.getPriority(self), activity is last while is_running_lock.acquire(0): try: - for last in sorted(activity_dict.itervalues(), key=sort_key): + for last in sorted(activity_dict.values(), key=sort_key): # Transaction processing is the responsability of the activity if not last.dequeueMessage(inner_self, processing_node): break diff --git a/product/CMFActivity/tests/testCMFActivity.py b/product/CMFActivity/tests/testCMFActivity.py index 890090318f9040eaaf2a67f3373ee2bc8eba7a5a..91bee9e16550ed08f3bbf9f4430eb8c2fd467d4c 100644 --- a/product/CMFActivity/tests/testCMFActivity.py +++ b/product/CMFActivity/tests/testCMFActivity.py @@ -836,24 +836,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.DeferredSetTitleActivity('SQLQueue') - def test_03_DeferredSetTitleRAMDict(self, quiet=0, run=run_all_test): - # Test if we can add a complete sales order - if not run: return - if not quiet: - message = '\nTest Deferred Set Title RAMDict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.DeferredSetTitleActivity('RAMDict') - - def test_04_DeferredSetTitleRAMQueue(self, quiet=0, run=run_all_test): - # Test if we can add a complete sales order - if not run: return - if not quiet: - message = '\nTest Deferred Set Title RAMQueue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.DeferredSetTitleActivity('RAMQueue') - def test_05_InvokeAndCancelSQLDict(self, quiet=0, run=run_all_test): # Test if we can add a complete sales order if not run: return @@ -872,24 +854,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.InvokeAndCancelActivity('SQLQueue') - def test_07_InvokeAndCancelRAMDict(self, quiet=0, run=run_all_test): - # Test if we can add a complete sales order - if not run: return - if not quiet: - message = '\nTest Invoke And Cancel RAMDict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.InvokeAndCancelActivity('RAMDict') - - def test_08_InvokeAndCancelRAMQueue(self, quiet=0, run=run_all_test): - # Test if we can add a complete sales order - if not run: return - if not quiet: - message = '\nTest Invoke And Cancel RAMQueue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.InvokeAndCancelActivity('RAMQueue') - def test_09_CallOnceWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -908,24 +872,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.CallOnceWithActivity('SQLQueue') - def test_11_CallOnceWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nCall Once With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.CallOnceWithActivity('RAMDict') - - def test_12_CallOnceWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nCall Once With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.CallOnceWithActivity('RAMQueue') - def test_13_TryMessageWithErrorOnSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -944,24 +890,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryMessageWithErrorOnActivity('SQLQueue') - def test_15_TryMessageWithErrorOnRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Message With Error On RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryMessageWithErrorOnActivity('RAMDict') - - def test_16_TryMessageWithErrorOnRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Message With Error On RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryMessageWithErrorOnActivity('RAMQueue') - def test_17_TryFlushActivityWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -980,24 +908,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryFlushActivity('SQLQueue') - def test_19_TryFlushActivityWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Flush Activity With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryFlushActivity('RAMDict') - - def test_20_TryFlushActivityWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Flush Activity With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryFlushActivity('RAMQueue') - def test_21_TryActivateInsideFlushWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1016,24 +926,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryActivateInsideFlush('SQLQueue') - def test_23_TryActivateInsideFlushWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Activate Inside Flush With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActivateInsideFlush('RAMDict') - - def test_24_TryActivateInsideFlushWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Activate Inside Flush With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActivateInsideFlush('RAMQueue') - def test_25_TryTwoMethodsWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1052,24 +944,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryTwoMethods('SQLQueue') - def test_27_TryTwoMethodsWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Two Methods With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryTwoMethods('RAMDict') - - def test_28_TryTwoMethodsWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Two Methods With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryTwoMethods('RAMQueue') - def test_29_TryTwoMethodsAndFlushThemWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1088,24 +962,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryTwoMethodsAndFlushThem('SQLQueue') - def test_31_TryTwoMethodsAndFlushThemWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Two Methods And Flush Them With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryTwoMethodsAndFlushThem('RAMDict') - - def test_32_TryTwoMethodsAndFlushThemWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Two Methods And Flush Them With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryTwoMethodsAndFlushThem('RAMQueue') - def test_33_TryActivateFlushActivateTicWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1124,24 +980,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryActivateFlushActivateTic('SQLQueue') - def test_35_TryActivateFlushActivateTicWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Activate Flush Activate Tic With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActivateFlushActivateTic('RAMDict') - - def test_36_TryActivateFlushActivateTicWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Activate Flush Activate Tic With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActivateFlushActivateTic('RAMQueue') - def test_37_TryActivateFlushActivateTicWithMultipleActivities(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1170,24 +1008,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryActivateFlushActivateTic('SQLQueue',commit_sub=1) - def test_40_TryCommitSubTransactionWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Commit Sub Transaction With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActivateFlushActivateTic('RAMDict',commit_sub=1) - - def test_41_TryCommitSubTransactionWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Commit Sub Transaction With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActivateFlushActivateTic('RAMQueue',commit_sub=1) - def test_42_TryRenameObjectWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1206,24 +1026,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.DeferredSetTitleWithRenamedObject('SQLQueue') - def test_44_TryRenameObjectWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Rename Object With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.DeferredSetTitleWithRenamedObject('RAMDict') - - def test_45_TryRenameObjectWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Rename Object With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.DeferredSetTitleWithRenamedObject('RAMQueue') - def test_46_TryActiveProcessWithSQLDict(self, quiet=0, run=run_all_test): # Test if we call methods only once if not run: return @@ -1242,24 +1044,6 @@ class TestCMFActivity(ERP5TypeTestCase, LogInterceptor): LOG('Testing... ',0,message) self.TryActiveProcess('SQLQueue') - def test_48_TryActiveProcessWithRAMDict(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Active Process With RAM Dict ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActiveProcess('RAMDict') - - def test_49_TryActiveProcessWithRAMQueue(self, quiet=0, run=run_all_test): - # Test if we call methods only once - if not run: return - if not quiet: - message = '\nTry Active Process With RAM Queue ' - ZopeTestCase._print(message) - LOG('Testing... ',0,message) - self.TryActiveProcess('RAMQueue') - def test_54_TryAfterMethodIdWithSQLDict(self, quiet=0, run=run_all_test): # Test if after_method_id can be used if not run: return