/**
* Fire this item.
*
* @param activation The activation to fire
* @throws org.drools.core.spi.ConsequenceException If an error occurs while attempting to fire
* the consequence.
*/
public synchronized void fireActivation(final Activation activation) throws ConsequenceException {
// We do this first as if a node modifies a fact that causes a recursion
// on an empty pattern
// we need to make sure it re-activates
this.workingMemory.startOperation();
isFiringActivation = true;
try {
final EventSupport eventsupport = (EventSupport) this.workingMemory;
eventsupport
.getAgendaEventSupport()
.fireBeforeActivationFired(activation, this.workingMemory);
if (activation.getActivationGroupNode() != null) {
// We know that this rule will cancel all other activations in the group
// so lets remove the information now, before the consequence fires
final InternalActivationGroup activationGroup =
activation.getActivationGroupNode().getActivationGroup();
activationGroup.removeActivation(activation);
clearAndCancelActivationGroup(activationGroup);
}
activation.setQueued(false);
try {
this.knowledgeHelper.setActivation(activation);
if (log.isTraceEnabled()) {
log.trace("Fire \"{}\" \n{}", activation.getRule().getName(), activation.getTuple());
}
activation.getConsequence().evaluate(this.knowledgeHelper, this.workingMemory);
this.knowledgeHelper.cancelRemainingPreviousLogicalDependencies();
this.knowledgeHelper.reset();
} catch (final Exception e) {
if (this.legacyConsequenceExceptionHandler != null) {
this.legacyConsequenceExceptionHandler.handleException(activation, this.workingMemory, e);
} else if (this.consequenceExceptionHandler != null) {
this.consequenceExceptionHandler.handleException(
activation, this.workingMemory.getKnowledgeRuntime(), e);
} else {
throw new RuntimeException(e);
}
} finally {
if (activation.getFactHandle() != null) {
// update the Activation in the WM
InternalFactHandle factHandle = activation.getFactHandle();
workingMemory
.getEntryPointNode()
.modifyActivation(factHandle, activation.getPropagationContext(), workingMemory);
activation.getPropagationContext().evaluateActionQueue(workingMemory);
}
// if the tuple contains expired events
for (LeftTuple tuple = activation.getTuple(); tuple != null; tuple = tuple.getParent()) {
if (tuple.getLastHandle() == null) {
// can be null for eval, not and exists that have no right input
continue;
}
if (tuple.getLastHandle().isEvent()) {
EventFactHandle handle = (EventFactHandle) tuple.getLastHandle();
// decrease the activation count for the event
handle.decreaseActivationsCount();
// handles "expire" only in stream mode.
if (handle.isExpired()) {
if (handle.getActivationsCount() <= 0) {
// and if no more activations, retract the handle
handle.getEntryPoint().retract(handle);
}
}
}
}
}
eventsupport.getAgendaEventSupport().fireAfterActivationFired(activation, this.workingMemory);
unstageActivations();
} finally {
isFiringActivation = false;
if (mustNotifyHalt) {
mustNotifyHalt = false;
notifyHalt();
}
this.workingMemory.endOperation();
}
}
private static void readBeliefSet(
MarshallerReaderContext context,
TruthMaintenanceSystem tms,
EqualityKey key,
ProtobufMessages.BeliefSet _beliefSet)
throws IOException, ClassNotFoundException {
InternalFactHandle handle = (InternalFactHandle) context.handles.get(_beliefSet.getHandleId());
for (ProtobufMessages.LogicalDependency _logicalDependency :
_beliefSet.getLogicalDependencyList()) {
ProtobufMessages.Activation _activation = _logicalDependency.getActivation();
Activation activation =
(Activation)
context
.filter
.getTuplesCache()
.get(
PersisterHelper.createActivationKey(
_activation.getPackageName(),
_activation.getRuleName(),
_activation.getTuple()))
.getObject();
Object object = null;
ObjectMarshallingStrategy strategy = null;
if (_logicalDependency.hasObjectStrategyIndex()) {
strategy = context.usedStrategies.get(_logicalDependency.getObjectStrategyIndex());
object =
strategy.unmarshal(
context.strategyContexts.get(strategy),
context,
_logicalDependency.getObject().toByteArray(),
(context.ruleBase == null) ? null : context.ruleBase.getRootClassLoader());
}
Object value = null;
if (_logicalDependency.hasValueStrategyIndex()) {
strategy = context.usedStrategies.get(_logicalDependency.getValueStrategyIndex());
value =
strategy.unmarshal(
context.strategyContexts.get(strategy),
context,
_logicalDependency.getValue().toByteArray(),
(context.ruleBase == null) ? null : context.ruleBase.getRootClassLoader());
}
ObjectTypeConf typeConf =
context
.wm
.getObjectTypeConfigurationRegistry()
.getObjectTypeConf(
((NamedEntryPoint) handle.getEntryPoint()).getEntryPoint(), handle.getObject());
tms.readLogicalDependency(
handle,
object,
value,
activation,
activation.getPropagationContext(),
activation.getRule(),
typeConf);
}
}
