Skip to content
Projects
Groups
Snippets
Help
Loading...
Help
Support
Keyboard shortcuts
?
Submit feedback
Contribute to GitLab
Sign in / Register
Toggle navigation
erp5
Project overview
Project overview
Details
Activity
Releases
Repository
Repository
Files
Commits
Branches
Tags
Contributors
Graph
Compare
Issues
0
Issues
0
List
Boards
Labels
Milestones
Merge Requests
0
Merge Requests
0
CI / CD
CI / CD
Pipelines
Jobs
Schedules
Analytics
Analytics
CI / CD
Repository
Value Stream
Wiki
Wiki
Snippets
Snippets
Members
Members
Collapse sidebar
Close sidebar
Activity
Graph
Create a new issue
Jobs
Commits
Issue Boards
Open sidebar
Titouan Soulard
erp5
Commits
0a1adf68
Commit
0a1adf68
authored
Dec 23, 2011
by
Julien Muchembled
Browse files
Options
Browse Files
Download
Email Patches
Plain Diff
CMFActivity: drop RAMDict & RAMQueue
parent
ae7a36f3
Changes
8
Show whitespace changes
Inline
Side-by-side
Showing
8 changed files
with
22 additions
and
581 deletions
+22
-581
product/CMFActivity/Activity/Queue.py
product/CMFActivity/Activity/Queue.py
+3
-3
product/CMFActivity/Activity/RAMDict.py
product/CMFActivity/Activity/RAMDict.py
+0
-179
product/CMFActivity/Activity/RAMQueue.py
product/CMFActivity/Activity/RAMQueue.py
+0
-144
product/CMFActivity/Activity/SQLBase.py
product/CMFActivity/Activity/SQLBase.py
+2
-2
product/CMFActivity/Activity/SQLDict.py
product/CMFActivity/Activity/SQLDict.py
+12
-19
product/CMFActivity/Activity/SQLQueue.py
product/CMFActivity/Activity/SQLQueue.py
+2
-15
product/CMFActivity/ActivityTool.py
product/CMFActivity/ActivityTool.py
+3
-3
product/CMFActivity/tests/testCMFActivity.py
product/CMFActivity/tests/testCMFActivity.py
+0
-216
No files found.
product/CMFActivity/Activity/Queue.py
View file @
0a1adf68
...
...
@@ -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
):
"""
...
...
product/CMFActivity/Activity/RAMDict.py
deleted
100644 → 0
View file @
ae7a36f3
##############################################################################
#
# 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
)
product/CMFActivity/Activity/RAMQueue.py
deleted
100644 → 0
View file @
ae7a36f3
##############################################################################
#
# 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
)
product/CMFActivity/Activity/SQLBase.py
View file @
0a1adf68
...
...
@@ -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.
"""
...
...
product/CMFActivity/Activity/SQLDict.py
View file @
0a1adf68
...
...
@@ -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
)
product/CMFActivity/Activity/SQLQueue.py
View file @
0a1adf68
...
...
@@ -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
=
RAMQueu
e
.
getPriority
(
self
,
activity_tool
)
default
=
SQLBas
e
.
getPriority
(
self
,
activity_tool
)
return
self
.
_getPriority
(
activity_tool
,
method
,
default
)
registerActivity
(
SQLQueue
)
product/CMFActivity/ActivityTool.py
View file @
0a1adf68
...
...
@@ -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
.
iter
values
(),
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
...
...
product/CMFActivity/tests/testCMFActivity.py
View file @
0a1adf68
...
...
@@ -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
=
'
\
n
Test 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
=
'
\
n
Test 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
=
'
\
n
Test 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
=
'
\
n
Test 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
=
'
\
n
Call 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
=
'
\
n
Call 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
=
'
\
n
Try 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
...
...
Write
Preview
Markdown
is supported
0%
Try again
or
attach a new file
Attach a file
Cancel
You are about to add
0
people
to the discussion. Proceed with caution.
Finish editing this message first!
Cancel
Please
register
or
sign in
to comment