12:20 p.m.
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>:
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