Does anyone have the same problem? I'm still stuck in this On 3/12/07, Carlos Henriquez <carlosalberto.henriquez(a)gmail.com&gt; wrote: -- Carlos Henriquez Wincor-Nixdorf +58-416-839.94.28

I don't have an application in PROD yet, I'm just working on a Proof of Concept with Drools 3.1.0M1 and Spring 1.2.8 but I have a similar situation as you in that I'll need to periodically reload Rules without restarting the App. This is what I've discover will work for us - not sure in your case, but here it is: I have objects called EventRuleBase objects which basically wrap RuleBase objects. Each instance of EventRuleBase object is tied to a resource (*.drl file on the file system for now, but in the future it may come from a DB). I then have a notion of RuleBaseManager object which is in charge of managing the collection of EventRuleBase objects. I use Spring to initialize and load all EventRuleBase objects individually and then register themselves with the RuleBaseManager object which records their instances in HashMap. The RuleBaseManager implements several methods: getWorkingMemory(...) and ruleChange(newEventRuleBase). The RuleBaseManager is a Singleton and the EventRuleBase objects are NOT singletons.... In my testing, I've discovered that when it's time to reload rules (some type of triggering mechanism must invoke this), I can ask Spring for a new instance of the EventRuleBase object by name (i.e. appContext.getBean(LOAD_rulebase) - it will fetch a brand new object which it will automatically reload from the underlying Resource (on the filesystem) - note that "singleton=false" bean configuration in Spring config is key for this. I can then hand the new instance of the new EventRuleBase object to the ruleChange(newEventRuleBase) method which it will then synchronize and 'swap-in' the new object into the HashMap it maintains. The clients that invoke subsequent getNewWorkingMemory() methods on the new EventRuleBase object will then start getting references to new object with NEW rules. I figured I'll need to protect the integrity of the hashmap using the JDK 1.5 implementation of ConcurrentHashMap which is very much possible using Spring 2.x - check out the documentation. Hope this helps. Regards - James' Carlos Henriquez wrote: -- View this message in context: http://www.nabble.com/Changing-rules-at-runtime-tf3392187.html#a9593359 Sent from the drools - user mailing list archive at Nabble.com.

Kind of new to JBoss Rules...I'm trying to fiigure out from what i have read so far if the following scenario is possible: 1. Start up an instance of a working memory (say, with dummy rule?) and keep it running, feeding it data objects to operate on from time to time. 2. As needed, kick off as many instance of working memory within the single rule base (in a separate thread) and keep them going as in step 1 The idea is to keep the rules engine running constantly, but kick off separate working-memory threads for the injection of various incoming rule sets and the objects those rule sets work on as needed. Can anyone provide some insight to this? Pointers to examples, perhaps? Alan J.

Mike, Thanks for you rresponse, however I'm not sure based on what we are wanting to do that we should use a single working memory. The proposed approach is: a rule has been added to the rule base, then a Fact (object) comes along and we instantiate a working memory and fire all rules relative to this working memory. The outcome from Drools is evaluated by another sw component, and it is decided to try a different rule with a given Fact. So, a new rule, rule #2, comes along with slightly different specifics on what it is supposed to match, so it is added to the rule base. Then, Fact #2 comes down the pipeline. A new working memory #2 is instantiated against the existing rulebase, Fact #2 is asserted, and fireAllRules() called against the working memory #2. The desired behavior is that only rule #2 is actually kicked into action (against Fact #2), since the first rule and fact is done with. We don't want the previous rules/facts in the rule base operating any longer. Maybe I just don't know enough about the proper application of rules when solving particular problems to ask the right questions -- my task is to expose JBoss rules as a service so I'm trying to understand a bit about it's operation. Thanks, aj -------------------------------------------- Alan R Jones Boeing S&IS Mission Systems Denver Engineering Center (BDEC) 303.307.3415 ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 2:23 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Hi Alan, A working memory is in essence always available\running whilst there is a reference to it; other than the "main" thread (on which your public static void main executes) you don't need to use other threads (but this obviously depends upon what exactly you're trying to achieve). The Rulebase can contain all of your production rules (in fact this is probably the recommended approach as, assuming some rules share a common pattern, the resulting RETE network will be optimised); and you can feed incoming objects (Facts in JBoss Rules terms) into one working memory created from the one Rulebase. As objects are asserted patterns (LHS) defining the rules are matched and, once fully matched, rules are activated for execution (RHS). Unfortunately I don't have any experience of JBoss Rules in a multi-threaded environment. For example:- public static void main(String args[]) { Rulebase rb = loadRuleBase(); WorkingMemory wm = rb.newWorkingMemory(); while (!exit()) { Collection c = getObjectsFromWherever(); assertObjectsIntoWorkingMemory(c, wm); wm.fireAllRules(); try { Thread.sleep(1000); } catch(InterruptedException ie) { } } } With kind regards, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto:rules-users-bounces@lists.jboss.org] On Behalf Of Jones, Alan R Sent: 27 March 2007 19:05 To: Rules Users List Subject: [rules-users] Rules Engine always running Kind of new to JBoss Rules...I'm trying to fiigure out from what i have read so far if the following scenario is possible: 1. Start up an instance of a working memory (say, with dummy rule?) and keep it running, feeding it data objects to operate on from time to time. 2. As needed, kick off as many instance of working memory within the single rule base (in a separate thread) and keep them going as in step 1 The idea is to keep the rules engine running constantly, but kick off separate working-memory threads for the injection of various incoming rule sets and the objects those rule sets work on as needed. Can anyone provide some insight to this? Pointers to examples, perhaps? Alan J.

Yes, some of these things are being considered. Thanks for your input , it has been helpful! aj ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 9:12 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running I assume rules are dynamically added to the Rulebase and that there is not a static set of rules associated with each application release? I believe new rules can be dynamically added to the existing Rulebase - whether existing WM's inherit the new rules I don't know. Agenda Groups could provide the control of which groups of rules fire. Also, if you retain FactHandles to all asserted Facts depending upon the decision made by the component the legacy Facts can be retracted before the new rule is activated. I assume you'll also have some "Rule life-cycle" control in place? Either removing rules from a Rulebase (I believe to be possible) or destroying redundant WM's (as per your proposal). Sorry, this doesn't add much more value - although input from more experienced users is welcomed. Cheers, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto:rules-users-bounces@lists.jboss.org] On Behalf Of Jones, Alan R Sent: 28 March 2007 15:29 To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Mike, Thanks for you rresponse, however I'm not sure based on what we are wanting to do that we should use a single working memory. The proposed approach is: a rule has been added to the rule base, then a Fact (object) comes along and we instantiate a working memory and fire all rules relative to this working memory. The outcome from Drools is evaluated by another sw component, and it is decided to try a different rule with a given Fact. So, a new rule, rule #2, comes along with slightly different specifics on what it is supposed to match, so it is added to the rule base. Then, Fact #2 comes down the pipeline. A new working memory #2 is instantiated against the existing rulebase, Fact #2 is asserted, and fireAllRules() called against the working memory #2. The desired behavior is that only rule #2 is actually kicked into action (against Fact #2), since the first rule and fact is done with. We don't want the previous rules/facts in the rule base operating any longer. Maybe I just don't know enough about the proper application of rules when solving particular problems to ask the right questions -- my task is to expose JBoss rules as a service so I'm trying to understand a bit about it's operation. Thanks, aj -------------------------------------------- Alan R Jones Boeing S&IS Mission Systems Denver Engineering Center (BDEC) 303.307.3415 ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 2:23 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Hi Alan, A working memory is in essence always available\running whilst there is a reference to it; other than the "main" thread (on which your public static void main executes) you don't need to use other threads (but this obviously depends upon what exactly you're trying to achieve). The Rulebase can contain all of your production rules (in fact this is probably the recommended approach as, assuming some rules share a common pattern, the resulting RETE network will be optimised); and you can feed incoming objects (Facts in JBoss Rules terms) into one working memory created from the one Rulebase. As objects are asserted patterns (LHS) defining the rules are matched and, once fully matched, rules are activated for execution (RHS). Unfortunately I don't have any experience of JBoss Rules in a multi-threaded environment. For example:- public static void main(String args[]) { Rulebase rb = loadRuleBase(); WorkingMemory wm = rb.newWorkingMemory(); while (!exit()) { Collection c = getObjectsFromWherever(); assertObjectsIntoWorkingMemory(c, wm); wm.fireAllRules(); try { Thread.sleep(1000); } catch(InterruptedException ie) { } } } With kind regards, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto:rules-users-bounces@lists.jboss.org] On Behalf Of Jones, Alan R Sent: 27 March 2007 19:05 To: Rules Users List Subject: [rules-users] Rules Engine always running Kind of new to JBoss Rules...I'm trying to fiigure out from what i have read so far if the following scenario is possible: 1. Start up an instance of a working memory (say, with dummy rule?) and keep it running, feeding it data objects to operate on from time to time. 2. As needed, kick off as many instance of working memory within the single rule base (in a separate thread) and keep them going as in step 1 The idea is to keep the rules engine running constantly, but kick off separate working-memory threads for the injection of various incoming rule sets and the objects those rule sets work on as needed. Can anyone provide some insight to this? Pointers to examples, perhaps? Alan J.

This is actually very close to the approach I am going to try: The caching is replaced by an object representing/encapsulating a given rulebase created as a new/separate thread. A reference to said object is registered (cached?). When a Fact comes along, the appropriate rulebase/object is looked up and the fact is fed to it (the object has a method that takes the fact and asserts it into a new working memory), then the object fires the rule. Does this approach make sense? Thanks, aj ________________________________ From: Edson Tirelli [mailto:tirelli@post.com] Sent: Wednesday, March 28, 2007 11:03 AM To: Rules Users List Subject: Re: [rules-users] Rules Engine always running Alan, If you have different sets of rules that you want to apply in different circunstances, you can compile and cache each of this sets as a rulebase (note that the set may contain a single rule). Then, for each fact that arrives, you decide which is the rulebase that applies to it, create a working memory for that rulebase, assert the fact, run the rule and throw the working memory away (as, you mentioned you don't want this working memory anymore). You can, of course, work with a single rulebase and keep adding and removing rules from it, but it will be more expensive to handle that for the use case you described. If you are able to detail your use case, we may be able to help you more. Regards, Edson 2007/3/28, Jones, Alan R <alan.r.jones(a)boeing.com&gt;: Yes, some of these things are being considered. Thanks for your input , it has been helpful! aj ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 9:12 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running I assume rules are dynamically added to the Rulebase and that there is not a static set of rules associated with each application release? I believe new rules can be dynamically added to the existing Rulebase - whether existing WM's inherit the new rules I don't know. Agenda Groups could provide the control of which groups of rules fire. Also, if you retain FactHandles to all asserted Facts depending upon the decision made by the component the legacy Facts can be retracted before the new rule is activated. I assume you'll also have some "Rule life-cycle" control in place? Either removing rules from a Rulebase (I believe to be possible) or destroying redundant WM's (as per your proposal). Sorry, this doesn't add much more value - although input from more experienced users is welcomed. Cheers, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto:rules-users-bounces@lists.jboss.org] On Behalf Of Jones, Alan R Sent: 28 March 2007 15:29 To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Mike, Thanks for you rresponse, however I'm not sure based on what we are wanting to do that we should use a single working memory. The proposed approach is: a rule has been added to the rule base, then a Fact (object) comes along and we instantiate a working memory and fire all rules relative to this working memory. The outcome from Drools is evaluated by another sw component, and it is decided to try a different rule with a given Fact. So, a new rule, rule #2, comes along with slightly different specifics on what it is supposed to match, so it is added to the rule base. Then, Fact #2 comes down the pipeline. A new working memory #2 is instantiated against the existing rulebase, Fact #2 is asserted, and fireAllRules() called against the working memory #2. The desired behavior is that only rule #2 is actually kicked into action (against Fact #2), since the first rule and fact is done with. We don't want the previous rules/facts in the rule base operating any longer. Maybe I just don't know enough about the proper application of rules when solving particular problems to ask the right questions -- my task is to expose JBoss rules as a service so I'm trying to understand a bit about it's operation. Thanks, aj -------------------------------------------- Alan R Jones Boeing S&IS Mission Systems Denver Engineering Center (BDEC) 303.307.3415 ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 2:23 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Hi Alan, A working memory is in essence always available\running whilst there is a reference to it; other than the "main" thread (on which your public static void main executes) you don't need to use other threads (but this obviously depends upon what exactly you're trying to achieve). The Rulebase can contain all of your production rules (in fact this is probably the recommended approach as, assuming some rules share a common pattern, the resulting RETE network will be optimised); and you can feed incoming objects (Facts in JBoss Rules terms) into one working memory created from the one Rulebase. As objects are asserted patterns (LHS) defining the rules are matched and, once fully matched, rules are activated for execution (RHS). Unfortunately I don't have any experience of JBoss Rules in a multi-threaded environment. For example:- public static void main(String args[]) { Rulebase rb = loadRuleBase(); WorkingMemory wm = rb.newWorkingMemory(); while (!exit()) { Collection c = getObjectsFromWherever(); assertObjectsIntoWorkingMemory(c, wm); wm.fireAllRules(); try { Thread.sleep(1000); } catch(InterruptedException ie) { } } } With kind regards, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto:rules-users-bounces@lists.jboss.org] On Behalf Of Jones, Alan R Sent: 27 March 2007 19:05 To: Rules Users List Subject: [rules-users] Rules Engine always running Kind of new to JBoss Rules...I'm trying to fiigure out from what i have read so far if the following scenario is possible: 1. Start up an instance of a working memory (say, with dummy rule?) and keep it running, feeding it data objects to operate on from time to time. 2. As needed, kick off as many instance of working memory within the single rule base (in a separate thread) and keep them going as in step 1 The idea is to keep the rules engine running constantly, but kick off separate working-memory threads for the injection of various incoming rule sets and the objects those rule sets work on as needed. Can anyone provide some insight to this? Pointers to examples, perhaps? Alan J. _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users -- Edson Tirelli Software Engineer - JBoss Rules Core Developer Office: +55 11 3124-6000 Mobile: +55 11 9218-4151 JBoss, a division of Red Hat @ www.jboss.com

Thanks for your help! aj -------------------------------------------- Alan R Jones Boeing S&IS Mission Systems Denver Engineering Center (BDEC) 303.307.3415 ________________________________ From: Edson Tirelli [mailto:tirelli@post.com] Sent: Wednesday, March 28, 2007 12:21 PM To: Rules Users List Subject: Re: [rules-users] Rules Engine always running Yes, that is standard approach. Just don't share the same working memory among multiple threads (seems you are not doing that, so just reinforcing). The rule base may be shared, no problem. []s Edson 2007/3/28, Jones, Alan R <alan.r.jones(a)boeing.com&gt;: This is actually very close to the approach I am going to try: The caching is replaced by an object representing/encapsulating a given rulebase created as a new/separate thread. A reference to said object is registered (cached?). When a Fact comes along, the appropriate rulebase/object is looked up and the fact is fed to it (the object has a method that takes the fact and asserts it into a new working memory), then the object fires the rule. Does this approach make sense? Thanks, aj ________________________________ From: Edson Tirelli [mailto:tirelli@post.com] Sent: Wednesday, March 28, 2007 11:03 AM To: Rules Users List Subject: Re: [rules-users] Rules Engine always running Alan, If you have different sets of rules that you want to apply in different circunstances, you can compile and cache each of this sets as a rulebase (note that the set may contain a single rule). Then, for each fact that arrives, you decide which is the rulebase that applies to it, create a working memory for that rulebase, assert the fact, run the rule and throw the working memory away (as, you mentioned you don't want this working memory anymore). You can, of course, work with a single rulebase and keep adding and removing rules from it, but it will be more expensive to handle that for the use case you described. If you are able to detail your use case, we may be able to help you more. Regards, Edson 2007/3/28, Jones, Alan R <alan.r.jones(a)boeing.com&gt;: Yes, some of these things are being considered. Thanks for your input , it has been helpful! aj ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 9:12 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running I assume rules are dynamically added to the Rulebase and that there is not a static set of rules associated with each application release? I believe new rules can be dynamically added to the existing Rulebase - whether existing WM's inherit the new rules I don't know. Agenda Groups could provide the control of which groups of rules fire. Also, if you retain FactHandles to all asserted Facts depending upon the decision made by the component the legacy Facts can be retracted before the new rule is activated. I assume you'll also have some "Rule life-cycle" control in place? Either removing rules from a Rulebase (I believe to be possible) or destroying redundant WM's (as per your proposal). Sorry, this doesn't add much more value - although input from more experienced users is welcomed. Cheers, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto: rules-users-bounces(a)lists.jboss.org <mailto:rules-users-bounces@lists.jboss.org> ] On Behalf Of Jones, Alan R Sent: 28 March 2007 15:29 To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Mike, Thanks for you rresponse, however I'm not sure based on what we are wanting to do that we should use a single working memory. The proposed approach is: a rule has been added to the rule base, then a Fact (object) comes along and we instantiate a working memory and fire all rules relative to this working memory. The outcome from Drools is evaluated by another sw component, and it is decided to try a different rule with a given Fact. So, a new rule, rule #2, comes along with slightly different specifics on what it is supposed to match, so it is added to the rule base. Then, Fact #2 comes down the pipeline. A new working memory #2 is instantiated against the existing rulebase, Fact #2 is asserted, and fireAllRules() called against the working memory #2. The desired behavior is that only rule #2 is actually kicked into action (against Fact #2), since the first rule and fact is done with. We don't want the previous rules/facts in the rule base operating any longer. Maybe I just don't know enough about the proper application of rules when solving particular problems to ask the right questions -- my task is to expose JBoss rules as a service so I'm trying to understand a bit about it's operation. Thanks, aj -------------------------------------------- Alan R Jones Boeing S&IS Mission Systems Denver Engineering Center (BDEC) 303.307.3415 ________________________________ From: Anstis, Michael (M.) [mailto:manstis1@ford.com] Sent: Wednesday, March 28, 2007 2:23 AM To: Rules Users List Subject: RE: [rules-users] Rules Engine always running Hi Alan, A working memory is in essence always available\running whilst there is a reference to it; other than the "main" thread (on which your public static void main executes) you don't need to use other threads (but this obviously depends upon what exactly you're trying to achieve). The Rulebase can contain all of your production rules (in fact this is probably the recommended approach as, assuming some rules share a common pattern, the resulting RETE network will be optimised); and you can feed incoming objects (Facts in JBoss Rules terms) into one working memory created from the one Rulebase. As objects are asserted patterns (LHS) defining the rules are matched and, once fully matched, rules are activated for execution (RHS). Unfortunately I don't have any experience of JBoss Rules in a multi-threaded environment. For example:- public static void main(String args[]) { Rulebase rb = loadRuleBase(); WorkingMemory wm = rb.newWorkingMemory(); while (!exit()) { Collection c = getObjectsFromWherever(); assertObjectsIntoWorkingMemory(c, wm); wm.fireAllRules(); try { Thread.sleep(1000); } catch(InterruptedException ie) { } } } With kind regards, Mike ________________________________ From: rules-users-bounces(a)lists.jboss.org [mailto: rules-users-bounces(a)lists.jboss.org] On Behalf Of Jones, Alan R Sent: 27 March 2007 19:05 To: Rules Users List Subject: [rules-users] Rules Engine always running Kind of new to JBoss Rules...I'm trying to fiigure out from what i have read so far if the following scenario is possible: 1. Start up an instance of a working memory (say, with dummy rule?) and keep it running, feeding it data objects to operate on from time to time. 2. As needed, kick off as many instance of working memory within the single rule base (in a separate thread) and keep them going as in step 1 The idea is to keep the rules engine running constantly, but kick off separate working-memory threads for the injection of various incoming rule sets and the objects those rule sets work on as needed. Can anyone provide some insight to this? Pointers to examples, perhaps? Alan J. _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users -- Edson Tirelli Software Engineer - JBoss Rules Core Developer Office: +55 11 3124-6000 Mobile: +55 11 9218-4151 JBoss, a division of Red Hat @ www.jboss.com _______________________________________________ rules-users mailing list rules-users(a)lists.jboss.org https://lists.jboss.org/mailman/listinfo/rules-users -- Edson Tirelli Software Engineer - JBoss Rules Core Developer Office: +55 11 3124-6000 Mobile: +55 11 9218-4151 JBoss, a division of Red Hat @ www.jboss.com