org.drools.runtime.StatefulKnowledgeSession Java Examples

@Before
public void beforeTest() {
  // init
  data = spy( new RulesExecutorData() );
  ValueMetaInterface c1 = mock( ValueMetaInterface.class );
  when( c1.getName() ).thenReturn( "c1" );
  ValueMetaInterface c2 = mock( ValueMetaInterface.class );
  when( c2.getName() ).thenReturn( "c2" );
  List<ValueMetaInterface> initColumns = Arrays.asList( c1, c2 );

  Rules.Column fc1 = new Rules.Column();
  fc1.setName( "c1" );
  List<Rules.Column> fetchedColumns = new ArrayList<Rules.Column>( Arrays.asList( fc1 ) );
  List<Rules.Column> fetchedColumnsSpy = spy( fetchedColumns );

  StatefulKnowledgeSession session = mock( StatefulKnowledgeSession.class );
  doReturn( session ).when( data ).initNewKnowledgeSession();
  doReturn( fetchedColumnsSpy ).when( data ).fetchColumns( session );

  RowMetaInterface rowMeta = mock( RowMetaInterface.class );
  when( rowMeta.getValueMetaList() ).thenReturn( initColumns );
  data.initializeColumns( rowMeta );
}
 

public void execute(DelegateExecution execution) {
  ProcessDefinition processDefinition = ProcessDefinitionUtil.getProcessDefinition(execution.getProcessDefinitionId());
  String deploymentId = processDefinition.getDeploymentId();

  KnowledgeBase knowledgeBase = RulesHelper.findKnowledgeBaseByDeploymentId(deploymentId);
  StatefulKnowledgeSession ksession = knowledgeBase.newStatefulKnowledgeSession();

  if (variablesInputExpressions != null) {
    Iterator<Expression> itVariable = variablesInputExpressions.iterator();
    while (itVariable.hasNext()) {
      Expression variable = itVariable.next();
      ksession.insert(variable.getValue(execution));
    }
  }

  if (!rulesExpressions.isEmpty()) {
    RulesAgendaFilter filter = new RulesAgendaFilter();
    Iterator<Expression> itRuleNames = rulesExpressions.iterator();
    while (itRuleNames.hasNext()) {
      Expression ruleName = itRuleNames.next();
      filter.addSuffic(ruleName.getValue(execution).toString());
    }
    filter.setAccept(!exclude);
    ksession.fireAllRules(filter);

  } else {
    ksession.fireAllRules();
  }

  Collection<Object> ruleOutputObjects = ksession.getObjects();
  if (ruleOutputObjects != null && !ruleOutputObjects.isEmpty()) {
    Collection<Object> outputVariables = new ArrayList<Object>();
    for (Object object : ruleOutputObjects) {
      outputVariables.add(object);
    }
    execution.setVariable(resultVariable, outputVariables);
  }
  ksession.dispose();
  leave(execution);
}
 

protected Collection<Object> fetchColumns( StatefulKnowledgeSession session ) {
  Collection<Object> oList = session.getObjects( new ObjectFilter() {
    @Override
    public boolean accept( Object o ) {
      if ( o instanceof Column && !( (Column) o ).isExternalSource() ) {
        return true;
      }
      return false;
    }
  } );
  return oList;
}
 

protected StatefulKnowledgeSession initNewKnowledgeSession() {
  StatefulKnowledgeSession session = kbase.newStatefulKnowledgeSession();
  for ( int i = 0; i < columnList.length; i++ ) {
    session.insert( columnList[i] );
  }

  session.fireAllRules();
  return session;
}
 

public void execute() {
  StatefulKnowledgeSession session = initNewKnowledgeSession();

  Collection<Object> oList = fetchColumns( session );
  for ( Object o : oList ) {
    resultMap.put( ( (Column) o ).getName(), (Column) o );
  }

  session.dispose();
}
 

private FactHandle evaluate(StatefulKnowledgeSession ksession, FactHandle handle, Object obj) {
    if (handle == null) {
        ksession.setGlobal("delegator", new RuleTasksDelegator());
        handle = ksession.insert(obj);
    } else {
        ksession.update(handle, obj);
    }
    ksession.fireAllRules();
    if (log.isDebugEnabled()) {
        log.debug(String.format("Rule executed for: %s ", obj));
    }
    return handle;
}
 

public void setObsoleteCheckKnowledgeSession(
        StatefulKnowledgeSession obsoleteCheckKnowledgeSession) {
    this.obsoleteCheckKnowledgeSession = obsoleteCheckKnowledgeSession;
}
 

public StatefulKnowledgeSession getScaleCheckKnowledgeSession() {
    return scaleCheckKnowledgeSession;
}
 

public void setScaleCheckKnowledgeSession(
        StatefulKnowledgeSession scaleCheckKnowledgeSession) {
    this.scaleCheckKnowledgeSession = scaleCheckKnowledgeSession;
}
 

public StatefulKnowledgeSession getDependentScaleCheckKnowledgeSession() {
    return dependentScaleCheckKnowledgeSession;
}
 

public void setDependentScaleCheckKnowledgeSession(StatefulKnowledgeSession dependentScaleCheckKnowledgeSession) {
    this.dependentScaleCheckKnowledgeSession = dependentScaleCheckKnowledgeSession;
}
 

public StatefulKnowledgeSession getStatefulSession(String drlFileName) {
    StatefulKnowledgeSession ksession;
    ksession = knowledgeBases.get(drlFileName).newStatefulKnowledgeSession();
    ksession.setGlobal("log", RuleLog.getInstance());
    return ksession;
}
 

public StatefulKnowledgeSession getObsoleteCheckKnowledgeSession() {
    return obsoleteCheckKnowledgeSession;
}
 

public StatefulKnowledgeSession getMaxCheckKnowledgeSession() {
    return maxCheckKnowledgeSession;
}
 

public void setMinCheckKnowledgeSession(
        StatefulKnowledgeSession minCheckKnowledgeSession) {
    this.minCheckKnowledgeSession = minCheckKnowledgeSession;
}
 

public StatefulKnowledgeSession getMinCheckKnowledgeSession() {
    return minCheckKnowledgeSession;
}
 

public void execute(DelegateExecution execution) {
  ActivityExecution activityExecution = (ActivityExecution) execution;
  PvmProcessDefinition processDefinition = activityExecution.getActivity().getProcessDefinition();
  String deploymentId = processDefinition.getDeploymentId();
  
  KnowledgeBase knowledgeBase = RulesHelper.findKnowledgeBaseByDeploymentId(deploymentId); 
  StatefulKnowledgeSession ksession = knowledgeBase.newStatefulKnowledgeSession();
  
  if (variablesInputExpressions != null) {
    Iterator<Expression> itVariable = variablesInputExpressions.iterator();
    while (itVariable.hasNext()) {
      Expression variable = itVariable.next();
      ksession.insert(variable.getValue(execution));
    }
  }
  
  if (!rulesExpressions.isEmpty()) {
    RulesAgendaFilter filter = new RulesAgendaFilter();
    Iterator<Expression> itRuleNames = rulesExpressions.iterator();
    while (itRuleNames.hasNext()) {
      Expression ruleName = itRuleNames.next();
      filter.addSuffic(ruleName.getValue(execution).toString());
    }
    filter.setAccept(!exclude);
    ksession.fireAllRules(filter);
    
  } else {
    ksession.fireAllRules();
  }
  
  Collection<Object> ruleOutputObjects = ksession.getObjects();
  if (ruleOutputObjects != null && !ruleOutputObjects.isEmpty()) {
    Collection<Object> outputVariables = new ArrayList<Object>();
    for (Object object : ruleOutputObjects) {
      outputVariables.add(object);
    }
    execution.setVariable(resultVariable, outputVariables);
  }
  ksession.dispose();
  leave(activityExecution);
}