Пример #1
0
  public void testNewSessionFailBefore() throws Exception {
    KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
    kbuilder.add(ResourceFactory.newClassPathResource("sampleFailBefore.bpmn"), ResourceType.BPMN2);
    KnowledgeBase kbase = kbuilder.newKnowledgeBase();
    SessionManagerFactory factory = new NewSessionSessionManagerFactory(kbase);
    SessionManager sessionManager = factory.getSessionManager();

    try {
      ProcessInstance processInstance =
          sessionManager.getKnowledgeSession().startProcess("com.sample.bpmn.hello", null);
      fail("Started process instance " + processInstance.getId());
    } catch (RuntimeException e) {
      // do nothing
    }

    // TODO: whenever transaction fails, do we need to dispose? can we?
    // sessionManager.dispose();

    List<Status> statusses = new ArrayList<Status>();
    statusses.add(Status.Reserved);

    sessionManager = factory.getSessionManager();
    List<TaskSummary> tasks =
        sessionManager.getTaskService().getTasksAssignedAsPotentialOwner("mary", "en-UK");
    assertEquals(0, tasks.size());

    sessionManager.dispose();
    factory.dispose();
  }
Пример #2
0
  public void testNewSessionDispose() throws Exception {
    KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
    kbuilder.add(ResourceFactory.newClassPathResource("sample.bpmn"), ResourceType.BPMN2);
    KnowledgeBase kbase = kbuilder.newKnowledgeBase();
    SessionManagerFactory factory = new NewSessionSessionManagerFactory(kbase);
    final SessionManager sessionManager = factory.getSessionManager();
    UserTransaction ut = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");
    ut.begin();
    sessionManager.getKnowledgeSession().startProcess("com.sample.bpmn.hello", null);
    TransactionManagerServices.getTransactionManager()
        .getTransaction()
        .registerSynchronization(
            new Synchronization() {
              public void beforeCompletion() {}

              public void afterCompletion(int status) {
                try {
                  sessionManager.dispose();
                } catch (Exception e) {
                  // TODO Auto-generated catch block
                  e.printStackTrace();
                }
              }
            });
    ut.commit();
    factory.dispose();
  }
Пример #3
0
 public void testSingletonSessionMemory() throws Exception {
   for (int i = 0; i < 1000; i++) {
     KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
     kbuilder.add(ResourceFactory.newClassPathResource("sample.bpmn"), ResourceType.BPMN2);
     KnowledgeBase kbase = kbuilder.newKnowledgeBase();
     SessionManagerFactory factory = new SingletonSessionManagerFactory(kbase);
     SessionManager sessionManager = factory.getSessionManager();
     sessionManager.dispose();
     factory.dispose();
     System.gc();
     Thread.sleep(100);
     System.gc();
     System.out.println(Runtime.getRuntime().totalMemory() - Runtime.getRuntime().freeMemory());
   }
 }
Пример #4
0
  public void testNewSessionFailAfter() throws Exception {
    KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
    kbuilder.add(ResourceFactory.newClassPathResource("sampleFailAfter.bpmn"), ResourceType.BPMN2);
    KnowledgeBase kbase = kbuilder.newKnowledgeBase();
    SessionManagerFactory factory = new NewSessionSessionManagerFactory(kbase);
    SessionManager sessionManager = factory.getSessionManager();

    ProcessInstance processInstance =
        sessionManager.getKnowledgeSession().startProcess("com.sample.bpmn.hello", null);
    long workItemId =
        ((HumanTaskNodeInstance)
                ((WorkflowProcessInstance) processInstance).getNodeInstances().iterator().next())
            .getWorkItemId();
    long taskId = sessionManager.getTaskService().getTaskByWorkItemId(workItemId).getId();
    sessionManager.getTaskService().claim(taskId, "mary");

    List<Status> statusses = new ArrayList<Status>();
    statusses.add(Status.Reserved);

    List<TaskSummary> tasks =
        sessionManager.getTaskService().getTasksOwned("mary", statusses, "en-UK");
    assertEquals(1, tasks.size());

    taskId = tasks.get(0).getId();
    UserTransaction ut = (UserTransaction) new InitialContext().lookup("java:comp/UserTransaction");
    try {
      ut.begin();
      sessionManager.getTaskService().start(taskId, "mary");
      sessionManager.getTaskService().complete(taskId, "mary", null);
      fail("Task completed");
    } catch (RuntimeException e) {
      // do nothing
    }
    ut.rollback();

    // TODO: whenever transaction fails, do we need to dispose? can we?
    // sessionManager.dispose();

    sessionManager = factory.getSessionManager();
    tasks = sessionManager.getTaskService().getTasksOwned("mary", statusses, "en-UK");
    assertEquals(1, tasks.size());

    sessionManager.dispose();
    factory.dispose();
  }
Пример #5
0
 public void testNewSession() throws Exception {
   KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
   kbuilder.add(ResourceFactory.newClassPathResource("sample.bpmn"), ResourceType.BPMN2);
   KnowledgeBase kbase = kbuilder.newKnowledgeBase();
   SessionManagerFactory factory = new NewSessionSessionManagerFactory(kbase);
   completedStart = 0;
   for (int i = 0; i < nbThreadsProcess; i++) {
     new StartProcessRunnable(factory, i).run();
   }
   completedTask = 0;
   for (int i = 0; i < nbThreadsTask; i++) {
     new Thread(new CompleteTaskRunnable(factory, i)).start();
   }
   while (completedStart < nbThreadsProcess || completedTask < nbThreadsTask) {
     Thread.sleep(100);
   }
   factory.dispose();
   System.out.println("Done");
 }
  public static void main(final String[] args) {

    final KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();
    kbuilder.add(
        ResourceFactory.newClassPathResource(
            "WorkItemConsequence1.drl", WorkItemConsequenceExample1.class),
        ResourceType.DRL);

    final KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
    kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());

    if (kbuilder.hasErrors()) {
      throw new RuntimeException("Compilation error.\n" + kbuilder.getErrors().toString());
    }

    final StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();
    ksession
        .getWorkItemManager()
        .registerWorkItemHandler("EmailWorkItemHandler", new EmailWorkItemHandler());

    //        KnowledgeRuntimeLogger logger = KnowledgeRuntimeLoggerFactory.newFileLogger(ksession,
    // "log/WorkItemConsequence.log");

    // Brains does not cause concern
    PersonLocation brains = new PersonLocation("Brains", 5);
    ksession.insert(brains);
    ksession.fireAllRules();

    // Gargamel is too far away to care
    PersonLocation gargamel = new PersonLocation("Gargamel", 10);
    FactHandle gargamelFactHandle = ksession.insert(gargamel);
    ksession.fireAllRules();

    // Uh oh, Gargamel moves closer
    gargamel.setDistance(5);
    ksession.update(gargamelFactHandle, gargamel);
    ksession.fireAllRules();

    //        logger.close();

    ksession.dispose(); // Stateful rule session must always be disposed when finished
  }
Пример #7
0
  @Test
  public void testSubruleSubsumption1() throws Exception {

    VerifierBuilder vBuilder = VerifierBuilderFactory.newVerifierBuilder();

    Verifier verifier = vBuilder.newVerifier();

    verifier.addResourcesToVerify(
        ResourceFactory.newClassPathResource("SubsumptantSubRules1.drl", getClass()),
        ResourceType.DRL);

    //        for ( VerifierError error : verifier.getMissingClasses() ) {
    //            System.out.println( error.getMessage() );
    //        }

    assertFalse(verifier.hasErrors());

    boolean noProblems = verifier.fireAnalysis();
    assertTrue(noProblems);

    Collection<Object> subsumptionList =
        ((VerifierImpl) verifier)
            .getKnowledgeSession()
            .getObjects(new ClassObjectFilter(Subsumption.class));

    int count = 0;
    for (Object object : subsumptionList) {
      //                        System.out.println( " * " + ((Subsumption) object) );
      if (((VerifierComponent) ((Subsumption) object).getLeft())
          .getVerifierComponentType()
          .equals(VerifierComponentType.SUB_RULE)) {
        //                System.out.println( " ** " + ((SubRule) ((Subsumption)
        // object).getLeft()).getItems() + " - " + ((SubRule) ((Subsumption)
        // object).getRight()).getItems() );
        count++;
      }
    }
    assertEquals(2, count);

    verifier.dispose();
  }
  @Test
  public void testGlobal() throws Exception {
    Options xjcOpts = new Options();
    xjcOpts.setSchemaLanguage(Language.XMLSCHEMA);
    KnowledgeBuilder kbuilder = KnowledgeBuilderFactory.newKnowledgeBuilder();

    JaxbConfiguration jaxbConf = KnowledgeBuilderFactory.newJaxbConfiguration(xjcOpts, "xsd");

    kbuilder.add(
        ResourceFactory.newClassPathResource("order.xsd", getClass()), ResourceType.XSD, jaxbConf);

    assertFalse(kbuilder.hasErrors());

    kbuilder.add(
        ResourceFactory.newClassPathResource("test_Jaxb.drl", getClass()), ResourceType.DRL);

    KnowledgeBase kbase = KnowledgeBaseFactory.newKnowledgeBase();
    kbase.addKnowledgePackages(kbuilder.getKnowledgePackages());

    assertFalse(kbuilder.hasErrors());

    assertFalse(kbuilder.hasErrors());

    StatefulKnowledgeSession ksession = kbase.newStatefulKnowledgeSession();

    KnowledgeRuntimeCommand setGlobalStage =
        PipelineFactory.newStatefulKnowledgeSessionSetGlobal("order");

    JAXBContext jaxbCtx =
        KnowledgeBuilderHelper.newJAXBContext(
            jaxbConf.getClasses().toArray(new String[jaxbConf.getClasses().size()]), kbase);

    Unmarshaller unmarshaller = jaxbCtx.createUnmarshaller();
    Transformer transformer = PipelineFactory.newJaxbFromXmlTransformer(unmarshaller);
    transformer.setReceiver(setGlobalStage);

    Pipeline pipeline = PipelineFactory.newStatefulKnowledgeSessionPipeline(ksession);
    pipeline.setReceiver(transformer);

    String xml =
        StringUtils.readFileAsString(
            new InputStreamReader(getClass().getResourceAsStream("order.xml")));

    ResultHandlerImpl resultHandler = new ResultHandlerImpl();
    pipeline.insert(xml, resultHandler);

    // now round trip that global
    Action executeResult = PipelineFactory.newExecuteResultHandler();

    Action assignAsResult = PipelineFactory.newAssignObjectAsResult();
    assignAsResult.setReceiver(executeResult);

    // transformer = PipelineFactory.newXStreamToXmlTransformer( xstream );
    Marshaller marshaller = jaxbCtx.createMarshaller();
    transformer = PipelineFactory.newJaxbToXmlTransformer(marshaller);
    transformer.setReceiver(assignAsResult);

    KnowledgeRuntimeCommand getGlobalStage = PipelineFactory.newStatefulKnowledgeSessionGetGlobal();
    getGlobalStage.setReceiver(transformer);

    pipeline = PipelineFactory.newStatefulKnowledgeSessionPipeline(ksession);
    pipeline.setReceiver(getGlobalStage);

    resultHandler = new ResultHandlerImpl();
    pipeline.insert("order", resultHandler);

    assertEqualsIgnoreWhitespace(xml, (String) resultHandler.getObject());
  }