1:58 a.m.
Hello there,
I'm pretty new to OptaPlanner, and I must say I'm really impressed with the
maturity of it all. Great software with a great documentation !
I've been working on a variation of the Cloud Balancing example, with a few
differences, which make it look like the Machine Reassignment problem as
well :
- Some processes are already placed and are immovable (using a Selection
Filter checking a boolean property of the planning entity)
- The Computer (the planning variable) is nullable (basically this is
Multiple Muti-Dimensional Knapsack problem) which means I added a soft
constraint penalty for processes with a null host.
- Processes can only be of a few classes (which I called services, a
Problem Fact). Processes of a given service type have a certain amount of
required cpu and ram.
Taking these elements into account, I do get very good results with
OptaPlanner. However, the following constraints always put me into a score
trap :
- For some services, processes work in groups. For instance, if groups are
of size 3, having 7 processes is not any better than having 6 processes. If
there were already 2 processes (immovable and placed), I should only add 4
processes and not 5, even if there are enough resources. For this
constraint, I have tried using a rule (medium constraint) accumulating
processes of that service and using the modulo operator with the group size.
- Some services are dependant on one another. For instance, I know that if
I have n1 groups of processes of the service 1, I require Math.ceil(2.5*n1)
groups of processes of the service 2. I have implemented this similarly
with a medium constraint...
With any (or both) of these constraints, little to no processes of the
concerned services are added and I fail to reach a good solution. I have
tried benchmarking with several local search methods and various
parameters, but all give the same results...
I feel like the next logical step would be to used the often mentioned in
the documentation "Coarse Grained Moves" but I fail to locate any simple
example. The Nurse Rostering example seems to use that technique to some
extent but it seems like an overly complicated example, is it not.
Thank you very much for reading this far, if you have any question,
guideline, or just a trick, I'd be absolutely delighted to hear from you !
Cheers,
Woody
9:37 a.m.
1) There's 2 course grained moves out of the box in 6.1.0.CR1:
pillarChangeMove and pillarSwapMove.
And in 6.1.0.CR1 they also include subpillars (which is important).
http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/...
Start with trying those.
2) Then look into cartesianProduct selection and mimic selection (see docs).
The <cartesianProductMoveSelector> allows you to combine to existing
moves into a new one.
The mimic selection allows you to make sure that those 2 moves change
the same entity (if needed), but a different variable of course.
I am working on nearBySelection for 6.2 to allow it to select 2 entities
that are somehow "nearBy" to each other (for example in the same service
etc).
3) If the above don't help enough, there's always custom moves (see
docs): total freedom, but the devil is in the details :)
On 24-06-14 01:58, DwProd . wrote:
Hello there,
I'm pretty new to OptaPlanner, and I must say I'm really impressed
with the maturity of it all. Great software with a great documentation !
I've been working on a variation of the Cloud Balancing example, with
a few differences, which make it look like the Machine Reassignment
problem as well :
- Some processes are already placed and are immovable (using a
Selection Filter checking a boolean property of the planning entity)
- The Computer (the planning variable) is nullable (basically this is
Multiple Muti-Dimensional Knapsack problem) which means I added a soft
constraint penalty for processes with a null host.
- Processes can only be of a few classes (which I called services, a
Problem Fact). Processes of a given service type have a certain amount
of required cpu and ram.
Taking these elements into account, I do get very good results with
OptaPlanner. However, the following constraints always put me into a
score trap :
- For some services, processes work in groups. For instance, if groups
are of size 3, having 7 processes is not any better than having 6
processes. If there were already 2 processes (immovable and placed), I
should only add 4 processes and not 5, even if there are enough
resources. For this constraint, I have tried using a rule (medium
constraint) accumulating processes of that service and using the
modulo operator with the group size.
- Some services are dependant on one another. For instance, I know
that if I have n1 groups of processes of the service 1, I require
Math.ceil(2.5*n1) groups of processes of the service 2. I have
implemented this similarly with a medium constraint...
With any (or both) of these constraints, little to no processes of the
concerned services are added and I fail to reach a good solution. I
have tried benchmarking with several local search methods and various
parameters, but all give the same results...
I feel like the next logical step would be to used the often mentioned
in the documentation "Coarse Grained Moves" but I fail to locate any
simple example. The Nurse Rostering example seems to use that
technique to some extent but it seems like an overly complicated
example, is it not.
Thank you very much for reading this far, if you have any question,
guideline, or just a trick, I'd be absolutely delighted to hear from you !
Cheers,
Woody
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
12:58 p.m.
Thanks a lot for your answer !
1) I don't think pillar based moves are what I'm looking for, except if I
can select a pillar based on a Problem Fact (its service in my case) and
then spread the different entities of the pillar on the available hosts
(basically setting possibly different planning variables for the entities
of the pillar).
2) cartesianProductMoveSelector seem more like it, but the number of moves
to combine is somewhat static is it not ? I can't for instance specify in a
Planning Entity (using a property) that its move should be combined with n
other moves of processes of the same type ?
3) I feel like my usecase is complicated enough to have to resort to that
if there is no built in way to handle it... Does this work by implementing
a MoveListFactory, or a CompositeMove ? I don't think I quite get the
difference to be honest...
Thanks again for your time,
Cheers,
Woody
2014-06-25 9:37 GMT+02:00 Geoffrey De Smet <ge0ffrey.spam(a)gmail.com>:
1) There's 2 course grained moves out of the box in 6.1.0.CR1:
pillarChangeMove and pillarSwapMove.
And in 6.1.0.CR1 they also include subpillars (which is important).
http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/...
Start with trying those.
2) Then look into cartesianProduct selection and mimic selection (see
docs).
The <cartesianProductMoveSelector> allows you to combine to existing moves
into a new one.
The mimic selection allows you to make sure that those 2 moves change the
same entity (if needed), but a different variable of course.
I am working on nearBySelection for 6.2 to allow it to select 2 entities
that are somehow "nearBy" to each other (for example in the same service
etc).
3) If the above don't help enough, there's always custom moves (see docs):
total freedom, but the devil is in the details :)
On 24-06-14 01:58, DwProd . wrote:
Hello there,
I'm pretty new to OptaPlanner, and I must say I'm really impressed with
the maturity of it all. Great software with a great documentation !
I've been working on a variation of the Cloud Balancing example, with a
few differences, which make it look like the Machine Reassignment problem
as well :
- Some processes are already placed and are immovable (using a Selection
Filter checking a boolean property of the planning entity)
- The Computer (the planning variable) is nullable (basically this is
Multiple Muti-Dimensional Knapsack problem) which means I added a soft
constraint penalty for processes with a null host.
- Processes can only be of a few classes (which I called services, a
Problem Fact). Processes of a given service type have a certain amount of
required cpu and ram.
Taking these elements into account, I do get very good results with
OptaPlanner. However, the following constraints always put me into a score
trap :
- For some services, processes work in groups. For instance, if groups
are of size 3, having 7 processes is not any better than having 6
processes. If there were already 2 processes (immovable and placed), I
should only add 4 processes and not 5, even if there are enough resources.
For this constraint, I have tried using a rule (medium constraint)
accumulating processes of that service and using the modulo operator with
the group size.
- Some services are dependant on one another. For instance, I know that if
I have n1 groups of processes of the service 1, I require Math.ceil(2.5*n1)
groups of processes of the service 2. I have implemented this similarly
with a medium constraint...
With any (or both) of these constraints, little to no processes of the
concerned services are added and I fail to reach a good solution. I have
tried benchmarking with several local search methods and various
parameters, but all give the same results...
I feel like the next logical step would be to used the often mentioned
in the documentation "Coarse Grained Moves" but I fail to locate any simple
example. The Nurse Rostering example seems to use that technique to some
extent but it seems like an overly complicated example, is it not.
Thank you very much for reading this far, if you have any question,
guideline, or just a trick, I'd be absolutely delighted to hear from you !
Cheers,
Woody
_______________________________________________
rules-users mailing
listrules-users@lists.jboss.orghttps://lists.jboss.org/mailman/listinfo/rules-users
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
1:18 p.m.
On 25-06-14 12:58, DwProd . wrote:
Thanks a lot for your answer !
1) I don't think pillar based moves are what I'm looking for, except
if I can select a pillar based on a Problem Fact (its service in my
case) and then spread the different entities of the pillar on the
available hosts (basically setting possibly different planning
variables for the entities of the pillar).
2) cartesianProductMoveSelector seem more like it, but the number of
moves to combine is somewhat static is it not ? I can't for instance
specify in a Planning Entity (using a property) that its move should
be combined with n other moves of processes of the same type ?
That would be
nearBySelection... (note: the name might change before I
implement).
You need to be able to tell optaplanner that processes of the same type
are "near" (~related) to each other and should be moved together.
As stated before, I am working on this for 6.2.
3) I feel like my usecase is complicated enough to have to resort to
that if there is no built in way to handle it... Does this work by
implementing a MoveListFactory, or a CompositeMove ? I don't think I
quite get the difference to be honest...
If you write a custom MoveListFactory (or
MoveIteratorFactory), you
could still opt to go with the build-in moves (such as ChangeMove) or
combinations of those with CompositeMove. However, because those
build-in moves require reflection stuff (VariableDescriptor etc), it's
probably easier to just to write a domain-specific Move.
See the examples that have custom moves.
Thanks again for your time,
Cheers,
Woody
2014-06-25 9:37 GMT+02:00 Geoffrey De Smet <ge0ffrey.spam(a)gmail.com
<mailto:ge0ffrey.spam@gmail.com>>:
1) There's 2 course grained moves out of the box in 6.1.0.CR1:
pillarChangeMove and pillarSwapMove.
And in 6.1.0.CR1 they also include subpillars (which is important).
http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/...
Start with trying those.
2) Then look into cartesianProduct selection and mimic selection
(see docs).
The <cartesianProductMoveSelector> allows you to combine to
existing moves into a new one.
The mimic selection allows you to make sure that those 2 moves
change the same entity (if needed), but a different variable of
course.
I am working on nearBySelection for 6.2 to allow it to select 2
entities that are somehow "nearBy" to each other (for example in
the same service etc).
3) If the above don't help enough, there's always custom moves
(see docs): total freedom, but the devil is in the details :)
On 24-06-14 01:58, DwProd . wrote:
> Hello there,
>
> I'm pretty new to OptaPlanner, and I must say I'm really
> impressed with the maturity of it all. Great software with a
> great documentation !
>
> I've been working on a variation of the Cloud Balancing example,
> with a few differences, which make it look like the Machine
> Reassignment problem as well :
>
> - Some processes are already placed and are immovable (using a
> Selection Filter checking a boolean property of the planning entity)
> - The Computer (the planning variable) is nullable (basically
> this is Multiple Muti-Dimensional Knapsack problem) which means I
> added a soft constraint penalty for processes with a null host.
> - Processes can only be of a few classes (which I called
> services, a Problem Fact). Processes of a given service type have
> a certain amount of required cpu and ram.
>
> Taking these elements into account, I do get very good results
> with OptaPlanner. However, the following constraints always put
> me into a score trap :
>
> - For some services, processes work in groups. For instance, if
> groups are of size 3, having 7 processes is not any better than
> having 6 processes. If there were already 2 processes (immovable
> and placed), I should only add 4 processes and not 5, even if
> there are enough resources. For this constraint, I have tried
> using a rule (medium constraint) accumulating processes of that
> service and using the modulo operator with the group size.
> - Some services are dependant on one another. For instance, I
> know that if I have n1 groups of processes of the service 1, I
> require Math.ceil(2.5*n1) groups of processes of the service 2. I
> have implemented this similarly with a medium constraint...
>
> With any (or both) of these constraints, little to no processes
> of the concerned services are added and I fail to reach a good
> solution. I have tried benchmarking with several local search
> methods and various parameters, but all give the same results...
>
> I feel like the next logical step would be to used the often
> mentioned in the documentation "Coarse Grained Moves" but I fail
> to locate any simple example. The Nurse Rostering example seems
> to use that technique to some extent but it seems like an overly
> complicated example, is it not.
>
> Thank you very much for reading this far, if you have any
> question, guideline, or just a trick, I'd be absolutely delighted
> to hear from you !
>
> Cheers,
>
> Woody
>
>
> _______________________________________________
> rules-users mailing list
> rules-users(a)lists.jboss.org <mailto:rules-users@lists.jboss.org>
> https://lists.jboss.org/mailman/listinfo/rules-users
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org <mailto:rules-users@lists.jboss.org>
https://lists.jboss.org/mailman/listinfo/rules-users
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
2:05 p.m.
Thanks a lot, yeah nearBySelection is probably what I would need, too bad
it's not out yet :(
As for the custom MoveListFactory, I found out what I'm trying to do has an
off the charts complexity. It basically has to find all subsets of planning
variables of a given size (combinations with repetition) which is the
number of entities I want to move at once... Worst case has a complexity of
something like O(4^n/sqrt(pi n))... It gets unmanagable pretty soon
unfortunately.
I'm not sure what I'll be doing but it seems like I'll have to do without
those constraints at first... Thanks again for your help however !
Best regards,
Woody
2014-06-25 13:18 GMT+02:00 Geoffrey De Smet <ge0ffrey.spam(a)gmail.com>:
On 25-06-14 12:58, DwProd . wrote:
Thanks a lot for your answer !
1) I don't think pillar based moves are what I'm looking for, except if
I can select a pillar based on a Problem Fact (its service in my case) and
then spread the different entities of the pillar on the available hosts
(basically setting possibly different planning variables for the entities
of the pillar).
2) cartesianProductMoveSelector seem more like it, but the number of
moves to combine is somewhat static is it not ? I can't for instance
specify in a Planning Entity (using a property) that its move should be
combined with n other moves of processes of the same type ?
That would be nearBySelection... (note: the name might change before I
implement).
You need to be able to tell optaplanner that processes of the same type
are "near" (~related) to each other and should be moved together.
As stated before, I am working on this for 6.2.
3) I feel like my usecase is complicated enough to have to resort to
that if there is no built in way to handle it... Does this work by
implementing a MoveListFactory, or a CompositeMove ? I don't think I quite
get the difference to be honest...
If you write a custom MoveListFactory (or MoveIteratorFactory), you could
still opt to go with the build-in moves (such as ChangeMove) or
combinations of those with CompositeMove. However, because those build-in
moves require reflection stuff (VariableDescriptor etc), it's probably
easier to just to write a domain-specific Move.
See the examples that have custom moves.
Thanks again for your time,
Cheers,
Woody
2014-06-25 9:37 GMT+02:00 Geoffrey De Smet <ge0ffrey.spam(a)gmail.com>:
> 1) There's 2 course grained moves out of the box in 6.1.0.CR1:
> pillarChangeMove and pillarSwapMove.
> And in 6.1.0.CR1 they also include subpillars (which is important).
>
>
http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/...
> Start with trying those.
>
> 2) Then look into cartesianProduct selection and mimic selection (see
> docs).
> The <cartesianProductMoveSelector> allows you to combine to existing
> moves into a new one.
> The mimic selection allows you to make sure that those 2 moves change the
> same entity (if needed), but a different variable of course.
> I am working on nearBySelection for 6.2 to allow it to select 2 entities
> that are somehow "nearBy" to each other (for example in the same service
> etc).
>
> 3) If the above don't help enough, there's always custom moves (see
> docs): total freedom, but the devil is in the details :)
>
>
> On 24-06-14 01:58, DwProd . wrote:
>
> Hello there,
>
> I'm pretty new to OptaPlanner, and I must say I'm really impressed with
> the maturity of it all. Great software with a great documentation !
>
> I've been working on a variation of the Cloud Balancing example, with a
> few differences, which make it look like the Machine Reassignment problem
> as well :
>
> - Some processes are already placed and are immovable (using a
> Selection Filter checking a boolean property of the planning entity)
> - The Computer (the planning variable) is nullable (basically this is
> Multiple Muti-Dimensional Knapsack problem) which means I added a soft
> constraint penalty for processes with a null host.
> - Processes can only be of a few classes (which I called services, a
> Problem Fact). Processes of a given service type have a certain amount of
> required cpu and ram.
>
> Taking these elements into account, I do get very good results with
> OptaPlanner. However, the following constraints always put me into a score
> trap :
>
> - For some services, processes work in groups. For instance, if groups
> are of size 3, having 7 processes is not any better than having 6
> processes. If there were already 2 processes (immovable and placed), I
> should only add 4 processes and not 5, even if there are enough resources.
> For this constraint, I have tried using a rule (medium constraint)
> accumulating processes of that service and using the modulo operator with
> the group size.
> - Some services are dependant on one another. For instance, I know that
> if I have n1 groups of processes of the service 1, I require
> Math.ceil(2.5*n1) groups of processes of the service 2. I have implemented
> this similarly with a medium constraint...
>
> With any (or both) of these constraints, little to no processes of the
> concerned services are added and I fail to reach a good solution. I have
> tried benchmarking with several local search methods and various
> parameters, but all give the same results...
>
> I feel like the next logical step would be to used the often mentioned
> in the documentation "Coarse Grained Moves" but I fail to locate any
simple
> example. The Nurse Rostering example seems to use that technique to some
> extent but it seems like an overly complicated example, is it not.
>
> Thank you very much for reading this far, if you have any question,
> guideline, or just a trick, I'd be absolutely delighted to hear from you !
>
> Cheers,
>
> Woody
>
>
> _______________________________________________
> rules-users mailing
listrules-users@lists.jboss.orghttps://lists.jboss.org/mailman/listinfo/rules-users
>
>
>
> _______________________________________________
> rules-users mailing list
> rules-users(a)lists.jboss.org
> https://lists.jboss.org/mailman/listinfo/rules-users
>
_______________________________________________
rules-users mailing
listrules-users@lists.jboss.orghttps://lists.jboss.org/mailman/listinfo/rules-users
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
2:14 p.m.
Look at MoveIteratorFactory, that allows you to select those moves JIT
(so without creating all of them like in MoveListFactory).
Also see JUST_IN_TIME vs caching explanation in docs.
Let's continue further questions/discussions on the new mailing list
http://www.optaplanner.org/community/forum.html
hth
On 27-06-14 14:05, DwProd . wrote:
Thanks a lot, yeah nearBySelection is probably what I would need, too
bad it's not out yet :(
As for the custom MoveListFactory, I found out what I'm trying to do
has an off the charts complexity. It basically has to find all subsets
of planning variables of a given size (combinations with repetition)
which is the number of entities I want to move at once... Worst case
has a complexity of something like O(4^n/sqrt(pi n))... It gets
unmanagable pretty soon unfortunately.
I'm not sure what I'll be doing but it seems like I'll have to do
without those constraints at first... Thanks again for your help however !
Best regards,
Woody
2014-06-25 13:18 GMT+02:00 Geoffrey De Smet <ge0ffrey.spam(a)gmail.com
<mailto:ge0ffrey.spam@gmail.com>>:
On 25-06-14 12:58, DwProd . wrote:
> Thanks a lot for your answer !
>
> 1) I don't think pillar based moves are what I'm looking for,
> except if I can select a pillar based on a Problem Fact (its
> service in my case) and then spread the different entities of the
> pillar on the available hosts (basically setting possibly
> different planning variables for the entities of the pillar).
>
> 2) cartesianProductMoveSelector seem more like it, but the number
> of moves to combine is somewhat static is it not ? I can't for
> instance specify in a Planning Entity (using a property) that its
> move should be combined with n other moves of processes of the
> same type ?
That would be nearBySelection... (note: the name might change
before I implement).
You need to be able to tell optaplanner that processes of the same
type are "near" (~related) to each other and should be moved together.
As stated before, I am working on this for 6.2.
>
> 3) I feel like my usecase is complicated enough to have to resort
> to that if there is no built in way to handle it... Does this
> work by implementing a MoveListFactory, or a CompositeMove ? I
> don't think I quite get the difference to be honest...
If you write a custom MoveListFactory (or MoveIteratorFactory),
you could still opt to go with the build-in moves (such as
ChangeMove) or combinations of those with CompositeMove. However,
because those build-in moves require reflection stuff
(VariableDescriptor etc), it's probably easier to just to write a
domain-specific Move.
See the examples that have custom moves.
>
> Thanks again for your time,
>
> Cheers,
>
> Woody
>
>
> 2014-06-25 9:37 GMT+02:00 Geoffrey De Smet
> <ge0ffrey.spam(a)gmail.com <mailto:ge0ffrey.spam@gmail.com>>:
>
> 1) There's 2 course grained moves out of the box in
> 6.1.0.CR1: pillarChangeMove and pillarSwapMove.
> And in 6.1.0.CR1 they also include subpillars (which is
> important).
>
http://docs.jboss.org/drools/release/latest/optaplanner-docs/html_single/...
> Start with trying those.
>
> 2) Then look into cartesianProduct selection and mimic
> selection (see docs).
> The <cartesianProductMoveSelector> allows you to combine to
> existing moves into a new one.
> The mimic selection allows you to make sure that those 2
> moves change the same entity (if needed), but a different
> variable of course.
> I am working on nearBySelection for 6.2 to allow it to select
> 2 entities that are somehow "nearBy" to each other (for
> example in the same service etc).
>
> 3) If the above don't help enough, there's always custom
> moves (see docs): total freedom, but the devil is in the
> details :)
>
>
> On 24-06-14 01:58, DwProd . wrote:
>> Hello there,
>>
>> I'm pretty new to OptaPlanner, and I must say I'm really
>> impressed with the maturity of it all. Great software with a
>> great documentation !
>>
>> I've been working on a variation of the Cloud Balancing
>> example, with a few differences, which make it look like the
>> Machine Reassignment problem as well :
>>
>> - Some processes are already placed and are immovable (using
>> a Selection Filter checking a boolean property of the
>> planning entity)
>> - The Computer (the planning variable) is nullable
>> (basically this is Multiple Muti-Dimensional Knapsack
>> problem) which means I added a soft constraint penalty for
>> processes with a null host.
>> - Processes can only be of a few classes (which I called
>> services, a Problem Fact). Processes of a given service type
>> have a certain amount of required cpu and ram.
>>
>> Taking these elements into account, I do get very good
>> results with OptaPlanner. However, the following constraints
>> always put me into a score trap :
>>
>> - For some services, processes work in groups. For instance,
>> if groups are of size 3, having 7 processes is not any
>> better than having 6 processes. If there were already 2
>> processes (immovable and placed), I should only add 4
>> processes and not 5, even if there are enough resources. For
>> this constraint, I have tried using a rule (medium
>> constraint) accumulating processes of that service and using
>> the modulo operator with the group size.
>> - Some services are dependant on one another. For instance,
>> I know that if I have n1 groups of processes of the service
>> 1, I require Math.ceil(2.5*n1) groups of processes of the
>> service 2. I have implemented this similarly with a medium
>> constraint...
>>
>> With any (or both) of these constraints, little to no
>> processes of the concerned services are added and I fail to
>> reach a good solution. I have tried benchmarking with
>> several local search methods and various parameters, but all
>> give the same results...
>>
>> I feel like the next logical step would be to used the often
>> mentioned in the documentation "Coarse Grained Moves" but I
>> fail to locate any simple example. The Nurse Rostering
>> example seems to use that technique to some extent but it
>> seems like an overly complicated example, is it not.
>>
>> Thank you very much for reading this far, if you have any
>> question, guideline, or just a trick, I'd be absolutely
>> delighted to hear from you !
>>
>> Cheers,
>>
>> Woody
>>
>>
>> _______________________________________________
>> rules-users mailing list
>> rules-users(a)lists.jboss.org <mailto:rules-users@lists.jboss.org>
>> https://lists.jboss.org/mailman/listinfo/rules-users
>
>
> _______________________________________________
> rules-users mailing list
> rules-users(a)lists.jboss.org <mailto:rules-users@lists.jboss.org>
> https://lists.jboss.org/mailman/listinfo/rules-users
>
>
>
>
> _______________________________________________
> rules-users mailing list
> rules-users(a)lists.jboss.org <mailto:rules-users@lists.jboss.org>
> https://lists.jboss.org/mailman/listinfo/rules-users
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org <mailto:rules-users@lists.jboss.org>
https://lists.jboss.org/mailman/listinfo/rules-users
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
3585
days inactive
3589
days old
5 comments
2 participants
participants (2)
-
DwProd . -
Geoffrey De Smet