DROOLS Flow as a Manufacturing process execution engine - Noob questions about events and concurrency
4:25 p.m.
First I want to thank Kris for responding to my direct email - very quick
response!
I'll move over to the mailing list for now.
I went and read the documentation for Flow and constructed a test flow
attached to an application that launches and controls it. I did this is
Eclipse for now using the GUI to test the applicability of the a work-flow
engine to a simple manufacturing task.
I attach a PNG image
(http://i349.photobucket.com/albums/q388/shooter_za/jvr_test_flow.png) and a
trimmed log of my flow just for interest sake at the end.
My test Java app starts the flow in a new thread and allows me to trigger
events in the flow with buttons (processInstance.signalEvent(String type,
Object data)). If I use Drools in my project, the events would be generated
by factory devices through an industrial protocol called OPC.
Some noob questions:
1. I need concurrent execution in my flow. I use Split nodes to do this. Is
this the correct way to achieve concurrency?
2. I need to construct control loops. Pieces of the flow that execute over
and over until a constraint
directs flow to an End node. I see no reason why loops cannot be done in
DROOLS flow.
3. My biggest problem at this time is that my flow executes, but "ignores"
Event nodes connected to AND Join nodes. The work-flow then ends and my
thread exits, although the End nodes in question are not reached according
to the log.
I suppose the engine determines that no terminating End node can be reached
and stops. I think that I maybe have an incorrect understanding of some
aspect of the DROOLS work-flow engine.
The core idea is to let one or more flows reach an AND Join node - and then
wait until all Event nodes attached to the AND Join node is triggered,
allowing the flow to continue.
Other problems I will not list here now, as I believe I may be able to
figure them out (variables, constraints). I just want to prove that Flow can
be used.
Anybody got any advice for me?
Thanks
Jean
http://n3.nabble.com/file/n706102/jvr_test_flow.png
BEFORE RULEFLOW NODE TRIGGERED node:Start[id=1]
BEFORE RULEFLOW NODE TRIGGERED node:AND - Split Flow - Two concurent
Processes[id=3]
BEFORE RULEFLOW NODE TRIGGERED node:Start Conveyor 1[id=4]
Start Conveyor 1
BEFORE RULEFLOW NODE TRIGGERED node:Stop Conveyor 1[id=38]
Stop Conveyor 1
BEFORE RULEFLOW NODE TRIGGERED node:End[id=9]
AFTER RULEFLOW NODE TRIGGERED node:End[id=9]
AFTER RULEFLOW NODE TRIGGERED node:Stop Conveyor 1[id=38]
AFTER RULEFLOW NODE TRIGGERED node:Start Conveyor 1[id=4]
BEFORE RULEFLOW NODE TRIGGERED node:Start Conveyor 2[id=5]
Start Conveyor 2
BEFORE RULEFLOW NODE TRIGGERED node:AND - Split Flow - Three concurent
Processes[id=6]
BEFORE RULEFLOW NODE TRIGGERED node:Start Conveyor 3[id=7]
Start Conveyor 3
BEFORE RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=10]
BEFORE RULEFLOW NODE TRIGGERED node:Load A onto conveyor 3[id=12]
Load one subassembly A on to Conveyor 3
BEFORE RULEFLOW NODE TRIGGERED node:Split - After Load A onto conveyor
3[id=17]
BEFORE RULEFLOW NODE TRIGGERED node:Discriminator - Join - Continue if any
input[id=13]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=51]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=51]
AFTER RULEFLOW NODE TRIGGERED node:Discriminator - Join - Continue if any
input[id=13]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=42]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=42]
AFTER RULEFLOW NODE TRIGGERED node:Split - After Load A onto conveyor
3[id=17]
AFTER RULEFLOW NODE TRIGGERED node:Load A onto conveyor 3[id=12]
AFTER RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=10]
AFTER RULEFLOW NODE TRIGGERED node:Start Conveyor 3[id=7]
BEFORE RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=26]
BEFORE RULEFLOW NODE TRIGGERED node:Load B onto Conveyor 2[id=8]
Load one subassembly B onto conveyor 2
BEFORE RULEFLOW NODE TRIGGERED node:Split - After load B onto conveyor
2[id=24]
BEFORE RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=47]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=52]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=52]
AFTER RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=47]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=49]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=49]
AFTER RULEFLOW NODE TRIGGERED node:Split - After load B onto conveyor
2[id=24]
AFTER RULEFLOW NODE TRIGGERED node:Load B onto Conveyor 2[id=8]
AFTER RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=26]
BEFORE RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=37]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=39]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=39]
AFTER RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=37]
AFTER RULEFLOW NODE TRIGGERED node:AND - Split Flow - Three concurent
Processes[id=6]
AFTER RULEFLOW NODE TRIGGERED node:Start Conveyor 2[id=5]
AFTER RULEFLOW NODE TRIGGERED node:AND - Split Flow - Two concurent
Processes[id=3]
AFTER RULEFLOW NODE TRIGGERED node:Start[id=1]
AFTER RULEFLOW STARTED
--
View this message in context:
http://n3.nabble.com/DROOLS-Flow-as-a-Manufacturing-process-execution-eng...
Sent from the Drools - User mailing list archive at Nabble.com.
5:14 p.m.
Good questions, Let me try to clarify them for you
On Thu, Apr 8, 2010 at 10:25 AM, jeanjvr <jeanjvr(a)live.co.za> wrote:
First I want to thank Kris for responding to my direct email - very quick
response!
I'll move over to the mailing list for now.
I went and read the documentation for Flow and constructed a test flow
attached to an application that launches and controls it. I did this is
Eclipse for now using the GUI to test the applicability of the a work-flow
engine to a simple manufacturing task.
I attach a PNG image
(http://i349.photobucket.com/albums/q388/shooter_za/jvr_test_flow.png) and
a
trimmed log of my flow just for interest sake at the end.
My test Java app starts the flow in a new thread and allows me to trigger
events in the flow with buttons (processInstance.signalEvent(String type,
Object data)). If I use Drools in my project, the events would be generated
by factory devices through an industrial protocol called OPC.
Some noob questions:
1. I need concurrent execution in my flow. I use Split nodes to do this. Is
this the correct way to achieve concurrency?
No really, if you want to represent with your business processes concurrent
tasks you use split and join nodes.
But if you are talking about multi-threaded programming this is not a good
choice. You can create multi-thread and concurrent code
to run inside a custom work item, but the concurrent threads will not be
visible in the processes graph.
2. I need to construct control loops. Pieces of the flow that execute over
and over until a constraint
directs flow to an End node. I see no reason why loops cannot be done in
DROOLS flow.
You can use for each nodes for that kind of behaviors. Where the loop will
be executed N times based on a variable/collection
3. My biggest problem at this time is that my flow executes, but "ignores"
Event nodes connected to AND Join nodes. The work-flow then ends and my
thread exits, although the End nodes in question are not reached according
to the log.
Can you provide a test case that demonstrate this behavior?
I suppose the engine determines that no terminating End node can be reached
and stops. I think that I maybe have an incorrect understanding of some
aspect of the DROOLS work-flow engine.
The core idea is to let one or more flows reach an AND Join node - and then
wait until all Event nodes attached to the AND Join node is triggered,
allowing the flow to continue.
Other problems I will not list here now, as I believe I may be able to
figure them out (variables, constraints). I just want to prove that Flow
can
be used.
Anybody got any advice for me?
Thanks
Jean
http://n3.nabble.com/file/n706102/jvr_test_flow.png
BEFORE RULEFLOW NODE TRIGGERED node:Start[id=1]
BEFORE RULEFLOW NODE TRIGGERED node:AND - Split Flow - Two concurent
Processes[id=3]
BEFORE RULEFLOW NODE TRIGGERED node:Start Conveyor 1[id=4]
Start Conveyor 1
BEFORE RULEFLOW NODE TRIGGERED node:Stop Conveyor 1[id=38]
Stop Conveyor 1
BEFORE RULEFLOW NODE TRIGGERED node:End[id=9]
AFTER RULEFLOW NODE TRIGGERED node:End[id=9]
AFTER RULEFLOW NODE TRIGGERED node:Stop Conveyor 1[id=38]
AFTER RULEFLOW NODE TRIGGERED node:Start Conveyor 1[id=4]
BEFORE RULEFLOW NODE TRIGGERED node:Start Conveyor 2[id=5]
Start Conveyor 2
BEFORE RULEFLOW NODE TRIGGERED node:AND - Split Flow - Three concurent
Processes[id=6]
BEFORE RULEFLOW NODE TRIGGERED node:Start Conveyor 3[id=7]
Start Conveyor 3
BEFORE RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=10]
BEFORE RULEFLOW NODE TRIGGERED node:Load A onto conveyor 3[id=12]
Load one subassembly A on to Conveyor 3
BEFORE RULEFLOW NODE TRIGGERED node:Split - After Load A onto conveyor
3[id=17]
BEFORE RULEFLOW NODE TRIGGERED node:Discriminator - Join - Continue if any
input[id=13]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=51]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=51]
AFTER RULEFLOW NODE TRIGGERED node:Discriminator - Join - Continue if any
input[id=13]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=42]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=42]
AFTER RULEFLOW NODE TRIGGERED node:Split - After Load A onto conveyor
3[id=17]
AFTER RULEFLOW NODE TRIGGERED node:Load A onto conveyor 3[id=12]
AFTER RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=10]
AFTER RULEFLOW NODE TRIGGERED node:Start Conveyor 3[id=7]
BEFORE RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=26]
BEFORE RULEFLOW NODE TRIGGERED node:Load B onto Conveyor 2[id=8]
Load one subassembly B onto conveyor 2
BEFORE RULEFLOW NODE TRIGGERED node:Split - After load B onto conveyor
2[id=24]
BEFORE RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=47]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=52]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=52]
AFTER RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=47]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=49]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=49]
AFTER RULEFLOW NODE TRIGGERED node:Split - After load B onto conveyor
2[id=24]
AFTER RULEFLOW NODE TRIGGERED node:Load B onto Conveyor 2[id=8]
AFTER RULEFLOW NODE TRIGGERED node:Discriminator Join - Continue if any
input[id=26]
BEFORE RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=37]
BEFORE RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=39]
AFTER RULEFLOW NODE TRIGGERED node:AND Join - Continue if all input[id=39]
AFTER RULEFLOW NODE TRIGGERED node:Disciminator - Join - Continue if any
input[id=37]
AFTER RULEFLOW NODE TRIGGERED node:AND - Split Flow - Three concurent
Processes[id=6]
AFTER RULEFLOW NODE TRIGGERED node:Start Conveyor 2[id=5]
AFTER RULEFLOW NODE TRIGGERED node:AND - Split Flow - Two concurent
Processes[id=3]
AFTER RULEFLOW NODE TRIGGERED node:Start[id=1]
AFTER RULEFLOW STARTED
--
View this message in context:
http://n3.nabble.com/DROOLS-Flow-as-a-Manufacturing-process-execution-eng...
Sent from the Drools - User mailing list archive at Nabble.com.
_______________________________________________
rules-users mailing list
rules-users(a)lists.jboss.org
https://lists.jboss.org/mailman/listinfo/rules-users
--
- http://salaboy.wordpress.com
- http://www.jbug.com.ar
- Salatino "Salaboy" Mauricio -
9:52 a.m.
Salaboy,
I put up a new simple diagram with red markers to show what I mean:
http://i349.photobucket.com/albums/q388/shooter_za/loop.jpg
http://n3.nabble.com/file/n707815/loop.jpg
1. Regarding concurrency. What I mean is that after I use an AND split node,
the flows going out from it will execute on their own paths at the same
time? I assume that DROOLS Flow achieves this in the engine with multiple
threads (in the background of the engine that we don't see)?
2. Regarding control loops. I mean here that according to the way I set up
the flow that a loop will be constructed in the logic with certain flows
executing multiple times. The motivation for this is that in manufacturing
more than one product is assembled in a run, and this is where the loops in
logic come from. I don't think I need a dedicated "for each" construct, but
I may be wrong. If you look at my DROOLS flow image, you'll see that I've
modeled three such "loops" into my flow and outlined one in the diagram
above. The compiler validates my flow as legal, I'm wondering if this is
really allowed in DROOLS.
3. Regarding the Events. In the diagram you can see I outlined an example of
two Events that are attached to an AND Join node. As I understand it, all
flows going into the AND Join node should be completed before it can
continue. Two of my flows here are Events. So in this example I want the one
"normal flow" to enter the AND Join node and at some later time when both
Events have fired I need the outgoing flow to continue.
When I run the process, it does not wait until the two Event nodes have
fired, it just executes until the AND Join node is encountered and the
overall process exists.
Jean
jeanjvr wrote:
I attach a PNG image
(http://i349.photobucket.com/albums/q388/shooter_za/jvr_test_flow.png) and
a trimmed log of my flow just for interest sake at the end.
My test Java app starts the flow in a new thread and allows me to trigger
events in the flow with buttons (processInstance.signalEvent(String type,
Object data)). If I use Drools in my project, the events would be
generated by factory devices through an industrial protocol called OPC.
Some noob questions:
1. I need concurrent execution in my flow. I use Split nodes to do this.
Is this the correct way to achieve concurrency?
2. I need to construct control loops. Pieces of the flow that execute over
and over until a constraint
directs flow to an End node. I see no reason why loops cannot be done in
DROOLS flow.
3. My biggest problem at this time is that my flow executes, but "ignores"
Event nodes connected to AND Join nodes. The work-flow then ends and my
thread exits, although the End nodes in question are not reached according
to the log.
I suppose the engine determines that no terminating End node can be
reached and stops. I think that I maybe have an incorrect understanding of
some aspect of the DROOLS work-flow engine.
The core idea is to let one or more flows reach an AND Join node - and
then wait until all Event nodes attached to the AND Join node is
triggered, allowing the flow to continue.
Other problems I will not list here now, as I believe I may be able to
figure them out (variables, constraints). I just want to prove that Flow
can be used.
--
View this message in context:
http://n3.nabble.com/DROOLS-Flow-as-a-Manufacturing-process-execution-eng...
Sent from the Drools - User mailing list archive at Nabble.com.
7:41 p.m.
On 09/04/2010 08:52, jeanjvr wrote:
Salaboy,
I put up a new simple diagram with red markers to show what I mean:
http://i349.photobucket.com/albums/q388/shooter_za/loop.jpg
http://n3.nabble.com/file/n707815/loop.jpg
I'm just looking at those flow diagrams. You may find some of that logic
can be modelled better and in a less brittle way with rules.
1. Regarding concurrency. What I mean is that after I use an AND split node,
the flows going out from it will execute on their own paths at the same
time? I assume that DROOLS Flow achieves this in the engine with multiple
threads (in the background of the engine that we don't see)?
No, it's single threaded. In general the execution of a path is
"almost
instant" spinning of threads for such short running work is normally
more overhead. Instead we recommend that if anything is not "almost
intant" to run it as an async action in it's own thread.
2. Regarding control loops. I mean here that according to the way I set up
the flow that a loop will be constructed in the logic with certain flows
executing multiple times. The motivation for this is that in manufacturing
more than one product is assembled in a run, and this is where the loops in
logic come from. I don't think I need a dedicated "for each" construct,
but
I may be wrong. If you look at my DROOLS flow image, you'll see that I've
modeled three such "loops" into my flow and outlined one in the diagram
above. The compiler validates my flow as legal, I'm wondering if this is
really allowed in DROOLS.
You'll find such loops make for quite brittle workflow, rules is
probably better.
3. Regarding the Events. In the diagram you can see I outlined an example of
two Events that are attached to an AND Join node. As I understand it, all
flows going into the AND Join node should be completed before it can
continue. Two of my flows here are Events. So in this example I want the one
"normal flow" to enter the AND Join node and at some later time when both
Events have fired I need the outgoing flow to continue.
When I run the process, it does not wait until the two Event nodes have
fired, it just executes until the AND Join node is encountered and the
overall process exists.
Each incoming event is effectively it's own propagation, the engine has
no way of knowing they should be "joined" together.
Mark
Jean
jeanjvr wrote:
>
> I attach a PNG image
> (http://i349.photobucket.com/albums/q388/shooter_za/jvr_test_flow.png) and
> a trimmed log of my flow just for interest sake at the end.
>
> My test Java app starts the flow in a new thread and allows me to trigger
> events in the flow with buttons (processInstance.signalEvent(String type,
> Object data)). If I use Drools in my project, the events would be
> generated by factory devices through an industrial protocol called OPC.
>
>
> Some noob questions:
>
> 1. I need concurrent execution in my flow. I use Split nodes to do this.
> Is this the correct way to achieve concurrency?
>
> 2. I need to construct control loops. Pieces of the flow that execute over
> and over until a constraint
> directs flow to an End node. I see no reason why loops cannot be done in
> DROOLS flow.
>
> 3. My biggest problem at this time is that my flow executes, but "ignores"
> Event nodes connected to AND Join nodes. The work-flow then ends and my
> thread exits, although the End nodes in question are not reached according
> to the log.
>
> I suppose the engine determines that no terminating End node can be
> reached and stops. I think that I maybe have an incorrect understanding of
> some aspect of the DROOLS work-flow engine.
>
> The core idea is to let one or more flows reach an AND Join node - and
> then wait until all Event nodes attached to the AND Join node is
> triggered, allowing the flow to continue.
>
> Other problems I will not list here now, as I believe I may be able to
> figure them out (variables, constraints). I just want to prove that Flow
> can be used.
>
>
>
4:20 p.m.
I managed to get my example working by:
1. Starting the process and then calling fireUntilHalt() solved my "ignored
event" problem :D
2. Changing the Join type from discriminator to XOR solved my problem that
actions in a "loop" only executed once (only got this problem after figuring
out the fireUntilHalt() problem)
Updated image of my simple manufacturing test flow included for interest
sake
http://n3.nabble.com/file/n708437/jvr_test_flow_4.png
Jean
--
View this message in context:
http://n3.nabble.com/DROOLS-Flow-as-a-Manufacturing-process-execution-eng...
Sent from the Drools - User mailing list archive at Nabble.com.
7:42 p.m.
On 09/04/2010 15:20, jeanjvr wrote:
I managed to get my example working by:
1. Starting the process and then calling fireUntilHalt() solved my "ignored
event" problem :D
2. Changing the Join type from discriminator to XOR solved my problem that
actions in a "loop" only executed once (only got this problem after figuring
out the fireUntilHalt() problem)
Updated image of my simple manufacturing test flow included for interest
sake
http://n3.nabble.com/file/n708437/jvr_test_flow_4.png
Would you be able to work this into an example that we can include in
the drools distribution? We are after some real world examples, and
would very much appreciate something like this :)
Mark
Jean
5147
days inactive
5153
days old
5 comments
3 participants
participants (3)
-
jeanjvr -
Mark Proctor -
Mauricio Salatino