1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16 package org.kuali.rice.kew.engine;
17
18 import org.apache.log4j.MDC;
19 import org.kuali.rice.coreservice.framework.CoreFrameworkServiceLocator;
20 import org.kuali.rice.coreservice.framework.parameter.ParameterService;
21 import org.kuali.rice.kew.actionrequest.ActionRequestValue;
22 import org.kuali.rice.kew.api.KewApiConstants;
23 import org.kuali.rice.kew.api.doctype.IllegalDocumentTypeException;
24 import org.kuali.rice.kew.api.exception.InvalidActionTakenException;
25 import org.kuali.rice.kew.api.exception.WorkflowException;
26 import org.kuali.rice.kew.engine.node.Branch;
27 import org.kuali.rice.kew.engine.node.BranchState;
28 import org.kuali.rice.kew.engine.node.ProcessDefinitionBo;
29 import org.kuali.rice.kew.engine.node.ProcessResult;
30 import org.kuali.rice.kew.engine.node.RouteNodeInstance;
31 import org.kuali.rice.kew.engine.node.RouteNodeUtils;
32 import org.kuali.rice.kew.engine.node.service.RouteNodeService;
33 import org.kuali.rice.kew.engine.transition.Transition;
34 import org.kuali.rice.kew.engine.transition.TransitionEngine;
35 import org.kuali.rice.kew.engine.transition.TransitionEngineFactory;
36 import org.kuali.rice.kew.exception.RouteManagerException;
37 import org.kuali.rice.kew.framework.postprocessor.AfterProcessEvent;
38 import org.kuali.rice.kew.framework.postprocessor.BeforeProcessEvent;
39 import org.kuali.rice.kew.framework.postprocessor.DocumentLockingEvent;
40 import org.kuali.rice.kew.framework.postprocessor.DocumentRouteLevelChange;
41 import org.kuali.rice.kew.framework.postprocessor.DocumentRouteStatusChange;
42 import org.kuali.rice.kew.framework.postprocessor.PostProcessor;
43 import org.kuali.rice.kew.framework.postprocessor.ProcessDocReport;
44 import org.kuali.rice.kew.postprocessor.DefaultPostProcessor;
45 import org.kuali.rice.kew.routeheader.DocumentRouteHeaderValue;
46 import org.kuali.rice.kew.routeheader.service.RouteHeaderService;
47 import org.kuali.rice.kew.service.KEWServiceLocator;
48 import org.kuali.rice.kew.util.PerformanceLogger;
49 import org.kuali.rice.krad.util.KRADConstants;
50
51 import java.sql.Timestamp;
52 import java.util.ArrayList;
53 import java.util.Collection;
54 import java.util.Iterator;
55 import java.util.LinkedList;
56 import java.util.List;
57
58
59
60
61
62
63
64
65
66 public class StandardWorkflowEngine implements WorkflowEngine {
67
68 private static final org.apache.log4j.Logger LOG = org.apache.log4j.Logger.getLogger(StandardWorkflowEngine.class);
69
70 protected final RouteHelper helper = new RouteHelper();
71 protected RouteNodeService routeNodeService;
72 protected RouteHeaderService routeHeaderService;
73 protected ParameterService parameterService;
74 protected OrchestrationConfig config;
75
76 public StandardWorkflowEngine() {}
77
78 protected StandardWorkflowEngine(RouteNodeService routeNodeService, RouteHeaderService routeHeaderService,
79 ParameterService parameterService, OrchestrationConfig config) {
80 this.routeNodeService = routeNodeService;
81 this.routeHeaderService = routeHeaderService;
82 this.parameterService = parameterService;
83 this.config = config;
84 }
85
86 public boolean isRunPostProcessorLogic() {
87 return this.config.isRunPostProcessorLogic();
88 }
89
90 public void process(String documentId, String nodeInstanceId) throws Exception {
91 if (documentId == null) {
92 throw new IllegalArgumentException("Cannot process a null document id.");
93 }
94 MDC.put("docId", documentId);
95 boolean success = true;
96 RouteContext context = RouteContext.createNewRouteContext();
97 try {
98 if ( LOG.isInfoEnabled() ) {
99 LOG.info("Aquiring lock on document " + documentId);
100 }
101 KEWServiceLocator.getRouteHeaderService().lockRouteHeader(documentId);
102 if ( LOG.isInfoEnabled() ) {
103 LOG.info("Aquired lock on document " + documentId);
104 }
105
106 DocumentRouteHeaderValue document = getRouteHeaderService().getRouteHeader(documentId);
107 context.setDocument(document);
108 lockAdditionalDocuments(document);
109
110 if ( LOG.isInfoEnabled() ) {
111 LOG.info("Processing document: " + documentId + " : " + nodeInstanceId);
112 }
113
114 try {
115 document = notifyPostProcessorBeforeProcess(document, nodeInstanceId);
116 context.setDocument(document);
117 } catch (Exception e) {
118 LOG.warn("Problems contacting PostProcessor before engine process", e);
119 throw new RouteManagerException("Problems contacting PostProcessor: " + e.getMessage());
120 }
121 if (!document.isRoutable()) {
122 LOG.debug("Document not routable so returning with doing no action");
123 return;
124 }
125 List<RouteNodeInstance> nodeInstancesToProcess = new LinkedList<RouteNodeInstance>();
126 if (nodeInstanceId == null) {
127
128 nodeInstancesToProcess.addAll(RouteNodeUtils.getActiveNodeInstances(document));
129 } else {
130 RouteNodeInstance instanceNode = RouteNodeUtils.findRouteNodeInstanceById(nodeInstanceId,document);
131 if (instanceNode == null) {
132 throw new IllegalArgumentException("Invalid node instance id: " + nodeInstanceId);
133 }
134 nodeInstancesToProcess.add(instanceNode);
135 }
136
137 context.setEngineState(new EngineState());
138 ProcessContext processContext = new ProcessContext(true, nodeInstancesToProcess);
139 try {
140 while (!nodeInstancesToProcess.isEmpty()) {
141 context.setNodeInstance((RouteNodeInstance) nodeInstancesToProcess.remove(0));
142 processContext = processNodeInstance(context, helper);
143 if (processContext.isComplete() && !processContext.getNextNodeInstances().isEmpty()) {
144 nodeInstancesToProcess.addAll(processContext.getNextNodeInstances());
145 }
146 }
147 context.setDocument(nodePostProcess(context));
148 } catch (Exception e) {
149 success = false;
150
151
152 throw new RouteManagerException(e, context);
153 }
154 } finally {
155 if ( LOG.isInfoEnabled() ) {
156 LOG.info((success ? "Successfully processed" : "Failed to process") + " document: " + documentId + " : " + nodeInstanceId);
157 }
158 try {
159 notifyPostProcessorAfterProcess(context.getDocument(), nodeInstanceId, success);
160 } catch (Exception e) {
161 LOG.warn("Problems contacting PostProcessor after engine process", e);
162 throw new RouteManagerException("Problems contacting PostProcessor", e, context);
163 }
164 RouteContext.clearCurrentRouteContext();
165 MDC.remove("docId");
166 }
167 }
168
169 protected ProcessContext processNodeInstance(RouteContext context, RouteHelper helper) throws Exception {
170 RouteNodeInstance nodeInstance = context.getNodeInstance();
171 if ( LOG.isDebugEnabled() ) {
172 LOG.debug("Processing node instance: " + nodeInstance.getRouteNode().getRouteNodeName());
173 }
174 if (checkAssertions(context)) {
175
176 return new ProcessContext();
177 }
178 TransitionEngine transitionEngine = TransitionEngineFactory.createTransitionEngine(nodeInstance);
179 ProcessResult processResult = transitionEngine.isComplete(context);
180 nodeInstance.setInitial(false);
181
182
183
184 if (processResult.isComplete()) {
185 if ( LOG.isDebugEnabled() ) {
186 LOG.debug("Routing node has completed: " + nodeInstance.getRouteNode().getRouteNodeName());
187 }
188
189 context.getEngineState().getCompleteNodeInstances().add(nodeInstance.getRouteNodeInstanceId());
190 List nextNodeCandidates = invokeTransition(context, context.getNodeInstance(), processResult, transitionEngine);
191
192
193
194
195
196
197 List<RouteNodeInstance> nodesToActivate = new ArrayList<RouteNodeInstance>();
198 if (!nextNodeCandidates.isEmpty()) {
199
200
201
202 ArrayList<RouteNodeInstance> nextNodeInstances = new ArrayList<RouteNodeInstance>();
203
204 for (Iterator nextIt = nextNodeCandidates.iterator(); nextIt.hasNext();) {
205 RouteNodeInstance nextNodeInstance = (RouteNodeInstance) nextIt.next();
206 transitionEngine = TransitionEngineFactory.createTransitionEngine(nextNodeInstance);
207 RouteNodeInstance currentNextNodeInstance = nextNodeInstance;
208 nextNodeInstance = transitionEngine.transitionTo(nextNodeInstance, context);
209
210
211 if (!currentNextNodeInstance.equals(nextNodeInstance)) {
212 currentNextNodeInstance.getPreviousNodeInstances().remove(nodeInstance);
213 }
214
215
216
217
218
219
220
221
222
223 nextNodeInstance.getPreviousNodeInstances().remove(nodeInstance);
224 nextNodeInstances.add(nextNodeInstance);
225 handleBackwardCompatibility(context, nextNodeInstance);
226
227 notifyNodeChange(context, nextNodeInstance);
228 nodesToActivate.add(nextNodeInstance);
229
230 }
231
232
233
234
235
236
237 nodeInstance.clearNextNodeInstances();
238 for (RouteNodeInstance nextNodeInstance : nextNodeInstances) {
239 nodeInstance.addNextNodeInstance(nextNodeInstance);
240 }
241 }
242
243
244 nodeInstance.setComplete(true);
245 nodeInstance.setActive(false);
246
247 for (RouteNodeInstance nodeToActivate : nodesToActivate) {
248 nodeToActivate.setActive(true);
249 }
250 } else {
251 nodeInstance.setComplete(false);
252 }
253
254 nodeInstance = saveNode(context, nodeInstance);
255 return new ProcessContext(nodeInstance.isComplete(), nodeInstance.getNextNodeInstances());
256 }
257
258
259
260
261
262
263
264
265 private boolean checkAssertions(RouteContext context) throws Exception {
266 if (context.getNodeInstance().isComplete()) {
267 if ( LOG.isDebugEnabled() ) {
268 LOG.debug("The node has already been completed: " + context.getNodeInstance().getRouteNode().getRouteNodeName());
269 }
270 return true;
271 }
272 if (isRunawayProcessDetected(context.getEngineState())) {
273
274 throw new WorkflowException("Detected runaway process.");
275 }
276 return false;
277 }
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306 private List invokeTransition(RouteContext context, RouteNodeInstance nodeInstance, ProcessResult processResult, TransitionEngine transitionEngine) throws Exception {
307 List nextNodeInstances = nodeInstance.getNextNodeInstances();
308 if (nextNodeInstances.isEmpty()) {
309 Transition result = transitionEngine.transitionFrom(context, processResult);
310 nextNodeInstances = result.getNextNodeInstances();
311 if (nextNodeInstances.isEmpty() && nodeInstance.isInProcess()) {
312 transitionEngine = TransitionEngineFactory.createTransitionEngine(nodeInstance.getProcess());
313 context.setNodeInstance(nodeInstance);
314 nextNodeInstances = invokeTransition(context, nodeInstance.getProcess(), processResult, transitionEngine);
315 }
316 }
317 return nextNodeInstances;
318 }
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335 private void notifyNodeChange(RouteContext context, RouteNodeInstance nextNodeInstance) throws Exception {
336 if (!context.isSimulation()) {
337 RouteNodeInstance nodeInstance = context.getNodeInstance();
338
339 String nextStatus = nodeInstance.getRouteNode().getNextDocStatus();
340 if (nextStatus != null && nextStatus.length() > 0){
341 context.getDocument().updateAppDocStatus(nextStatus);
342 }
343
344 DocumentRouteLevelChange event = new DocumentRouteLevelChange(context.getDocument().getDocumentId(), context.getDocument().getAppDocId(), CompatUtils.getLevelForNode(context.getDocument().getDocumentType(), context.getNodeInstance()
345 .getRouteNode().getRouteNodeName()), CompatUtils.getLevelForNode(context.getDocument().getDocumentType(), nextNodeInstance.getRouteNode().getRouteNodeName()), nodeInstance.getRouteNode().getRouteNodeName(), nextNodeInstance
346 .getRouteNode().getRouteNodeName(), nodeInstance.getRouteNodeInstanceId(), nextNodeInstance.getRouteNodeInstanceId());
347 context.setDocument(notifyPostProcessor(context.getDocument(), nodeInstance, event));
348 }
349 }
350
351 private void handleBackwardCompatibility(RouteContext context, RouteNodeInstance nextNodeInstance) {
352 context.getDocument().setDocRouteLevel(new Integer(context.getDocument().getDocRouteLevel().intValue() + 1));
353
354
355
356
357
358 saveDocument(context);
359 }
360
361 private void saveDocument(RouteContext context) {
362 if (!context.isSimulation()) {
363
364 DocumentRouteHeaderValue routeHeaderValue = KEWServiceLocator.getRouteHeaderService().
365 saveRouteHeader(context.getDocument());
366 context.setDocument(routeHeaderValue);
367 }
368 }
369
370 private Branch saveBranch(RouteContext context, Branch branch) {
371 if (!context.isSimulation()) {
372 return KEWServiceLocator.getRouteNodeService().save(branch);
373 }
374 return branch;
375 }
376
377 protected RouteNodeInstance saveNode(RouteContext context, RouteNodeInstance nodeInstance) {
378 if (!context.isSimulation()) {
379 nodeInstance = getRouteNodeService().save(nodeInstance);
380 } else {
381
382
383 for (Iterator<RouteNodeInstance> iterator = nodeInstance.getNextNodeInstances().iterator(); iterator.hasNext();) {
384 RouteNodeInstance routeNodeInstance = (RouteNodeInstance) iterator.next();
385 if (routeNodeInstance.getRouteNodeInstanceId() == null) {
386 routeNodeInstance.setRouteNodeInstanceId(context.getEngineState().getNextSimulationId());
387 }
388 }
389 if (nodeInstance.getProcess() != null && nodeInstance.getProcess().getRouteNodeInstanceId() == null) {
390 nodeInstance.getProcess().setRouteNodeInstanceId(context.getEngineState().getNextSimulationId());
391 }
392 if (nodeInstance.getBranch() != null && nodeInstance.getBranch().getBranchId() == null) {
393 nodeInstance.getBranch().setBranchId(context.getEngineState().getNextSimulationId());
394 }
395 }
396
397 return nodeInstance;
398 }
399
400
401
402 protected DocumentRouteHeaderValue nodePostProcess(RouteContext context) throws InvalidActionTakenException {
403 DocumentRouteHeaderValue document = context.getDocument();
404 Collection<RouteNodeInstance> activeNodes = RouteNodeUtils.getActiveNodeInstances(document);
405 boolean moreNodes = false;
406 for (Iterator<RouteNodeInstance> iterator = activeNodes.iterator(); iterator.hasNext();) {
407 RouteNodeInstance nodeInstance = (RouteNodeInstance) iterator.next();
408 moreNodes = moreNodes || !nodeInstance.isComplete();
409 }
410 List pendingRequests = KEWServiceLocator.getActionRequestService().findPendingByDoc(document.getDocumentId());
411 boolean activeApproveRequests = false;
412 boolean activeAckRequests = false;
413 for (Iterator iterator = pendingRequests.iterator(); iterator.hasNext();) {
414 ActionRequestValue request = (ActionRequestValue) iterator.next();
415 activeApproveRequests = request.isApproveOrCompleteRequest() || activeApproveRequests;
416 activeAckRequests = request.isAcknowledgeRequest() || activeAckRequests;
417 }
418
419 if (!document.isProcessed() && (!moreNodes || !activeApproveRequests)) {
420 if ( LOG.isDebugEnabled() ) {
421 LOG.debug("No more nodes for this document " + document.getDocumentId());
422 }
423
424 checkDefaultApprovalPolicy(document);
425 document.setApprovedDate(new Timestamp(System.currentTimeMillis()));
426
427 LOG.debug("Marking document processed");
428 DocumentRouteStatusChange event = new DocumentRouteStatusChange(document.getDocumentId(), document.getAppDocId(), document.getDocRouteStatus(), KewApiConstants.ROUTE_HEADER_PROCESSED_CD);
429 document.markDocumentProcessed();
430
431 notifyPostProcessor(context, event);
432 }
433
434
435
436 if (document.isProcessed()) {
437 DocumentRouteStatusChange event = new DocumentRouteStatusChange(document.getDocumentId(), document.getAppDocId(), document.getDocRouteStatus(), KewApiConstants.ROUTE_HEADER_FINAL_CD);
438 List actionRequests = KEWServiceLocator.getActionRequestService().findPendingByDoc(document.getDocumentId());
439 if (actionRequests.isEmpty()) {
440 document.markDocumentFinalized();
441
442 notifyPostProcessor(context, event);
443 } else {
444 boolean markFinalized = true;
445 for (Iterator iter = actionRequests.iterator(); iter.hasNext();) {
446 ActionRequestValue actionRequest = (ActionRequestValue) iter.next();
447 if (KewApiConstants.ACTION_REQUEST_ACKNOWLEDGE_REQ.equals(actionRequest.getActionRequested())) {
448 markFinalized = false;
449 }
450 }
451 if (markFinalized) {
452 document.markDocumentFinalized();
453
454 this.notifyPostProcessor(context, event);
455 }
456 }
457 }
458 saveDocument(context);
459 return document;
460 }
461
462
463
464
465
466
467
468
469
470 private void checkDefaultApprovalPolicy(DocumentRouteHeaderValue document) throws RouteManagerException {
471 if (!document.getDocumentType().getDefaultApprovePolicy().getPolicyValue().booleanValue()) {
472 LOG.debug("Checking if any requests have been generated for the document");
473 List requests = KEWServiceLocator.getActionRequestService().findAllActionRequestsByDocumentId(document.getDocumentId());
474 boolean approved = false;
475 for (Iterator iter = requests.iterator(); iter.hasNext();) {
476 ActionRequestValue actionRequest = (ActionRequestValue) iter.next();
477 if (actionRequest.isApproveOrCompleteRequest() && actionRequest.isDone()) {
478
479
480
481
482
483
484 LOG.debug("Found at least one processed approve request so document can be approved");
485 approved = true;
486 break;
487 }
488 }
489 if (!approved) {
490 LOG.debug("Document requires at least one request and none are present");
491
492 throw new RouteManagerException("Document should have generated at least one approval request.");
493 }
494 }
495 }
496
497 private DocumentRouteHeaderValue notifyPostProcessor(RouteContext context, DocumentRouteStatusChange event) {
498 DocumentRouteHeaderValue document = context.getDocument();
499 if (context.isSimulation()) {
500 return document;
501 }
502 if (hasContactedPostProcessor(context, event)) {
503 return document;
504 }
505 String documentId = event.getDocumentId();
506 PerformanceLogger performanceLogger = new PerformanceLogger(documentId);
507 ProcessDocReport processReport = null;
508 PostProcessor postProc = null;
509 try {
510
511 if (!isRunPostProcessorLogic()) {
512 postProc = new DefaultPostProcessor();
513 } else {
514 postProc = document.getDocumentType().getPostProcessor();
515 }
516 } catch (Exception e) {
517 LOG.error("Error retrieving PostProcessor for document " + document.getDocumentId(), e);
518 throw new RouteManagerException("Error retrieving PostProcessor for document " + document.getDocumentId(), e);
519 }
520 try {
521 processReport = postProc.doRouteStatusChange(event);
522 } catch (Exception e) {
523 LOG.error("Error notifying post processor", e);
524 throw new RouteManagerException(KewApiConstants.POST_PROCESSOR_FAILURE_MESSAGE, e);
525 } finally {
526 performanceLogger.log("Time to notifyPostProcessor of event " + event.getDocumentEventCode() + ".");
527 }
528
529 if (!processReport.isSuccess()) {
530 LOG.warn("PostProcessor failed to process document: " + processReport.getMessage());
531 throw new RouteManagerException(KewApiConstants.POST_PROCESSOR_FAILURE_MESSAGE + processReport.getMessage());
532 }
533 return document;
534 }
535
536
537
538
539
540
541
542
543
544
545
546 private boolean hasContactedPostProcessor(RouteContext context, DocumentRouteStatusChange event) {
547
548
549 Branch rootBranch = context.getDocument().getRootBranch();
550 String key = null;
551 if (KewApiConstants.ROUTE_HEADER_PROCESSED_CD.equals(event.getNewRouteStatus())) {
552 key = KewApiConstants.POST_PROCESSOR_PROCESSED_KEY;
553 } else if (KewApiConstants.ROUTE_HEADER_FINAL_CD.equals(event.getNewRouteStatus())) {
554 key = KewApiConstants.POST_PROCESSOR_FINAL_KEY;
555 } else {
556 return false;
557 }
558 BranchState branchState = null;
559 if (rootBranch != null) {
560 branchState = rootBranch.getBranchState(key);
561 } else {
562 return false;
563 }
564 if (branchState == null) {
565 branchState = new BranchState();
566 branchState.setKey(key);
567 branchState.setValue("true");
568 rootBranch.addBranchState(branchState);
569 saveBranch(context, rootBranch);
570 return false;
571 }
572 return "true".equals(branchState.getValue());
573 }
574
575
576
577
578
579
580
581
582 private DocumentRouteHeaderValue notifyPostProcessor(DocumentRouteHeaderValue document, RouteNodeInstance nodeInstance, DocumentRouteLevelChange event) {
583 document = getRouteHeaderService().saveRouteHeader(document);
584 ProcessDocReport report = null;
585 try {
586 PostProcessor postProcessor = null;
587
588 if (!isRunPostProcessorLogic()) {
589 postProcessor = new DefaultPostProcessor();
590 } else {
591 postProcessor = document.getDocumentType().getPostProcessor();
592 }
593 report = postProcessor.doRouteLevelChange(event);
594 } catch (Exception e) {
595 LOG.warn("Problems contacting PostProcessor", e);
596 throw new RouteManagerException("Problems contacting PostProcessor: " + e.getMessage());
597 }
598 document = getRouteHeaderService().getRouteHeader(document.getDocumentId());
599 if (!report.isSuccess()) {
600 LOG.error("PostProcessor rejected route level change::" + report.getMessage(), report.getProcessException());
601 throw new RouteManagerException("Route Level change failed in post processor::" + report.getMessage());
602 }
603 return document;
604 }
605
606
607
608
609
610 private DocumentRouteHeaderValue notifyPostProcessorBeforeProcess(DocumentRouteHeaderValue document, String nodeInstanceId) {
611 return notifyPostProcessorBeforeProcess(document, nodeInstanceId, new BeforeProcessEvent(document.getDocumentId(),document.getAppDocId(),nodeInstanceId));
612 }
613
614
615
616
617
618 private DocumentRouteHeaderValue notifyPostProcessorBeforeProcess(DocumentRouteHeaderValue document, String nodeInstanceId, BeforeProcessEvent event) {
619 ProcessDocReport report = null;
620 try {
621 PostProcessor postProcessor = null;
622
623 if (!isRunPostProcessorLogic()) {
624 postProcessor = new DefaultPostProcessor();
625 } else {
626 postProcessor = document.getDocumentType().getPostProcessor();
627 }
628 report = postProcessor.beforeProcess(event);
629 } catch (Exception e) {
630 LOG.warn("Problems contacting PostProcessor", e);
631 throw new RouteManagerException("Problems contacting PostProcessor: " + e.getMessage());
632 }
633 document = getRouteHeaderService().getRouteHeader(document.getDocumentId());
634 if (!report.isSuccess()) {
635 LOG.error("PostProcessor rejected route level change::" + report.getMessage(), report.getProcessException());
636 throw new RouteManagerException("Route Level change failed in post processor::" + report.getMessage());
637 }
638 return document;
639 }
640
641 protected void lockAdditionalDocuments(DocumentRouteHeaderValue document) throws Exception {
642 DocumentLockingEvent lockingEvent = new DocumentLockingEvent(document.getDocumentId(), document.getAppDocId());
643
644 PostProcessor postProcessor = null;
645
646 if (!isRunPostProcessorLogic()) {
647 postProcessor = new DefaultPostProcessor();
648 } else {
649 postProcessor = document.getDocumentType().getPostProcessor();
650 }
651 List<String> documentIdsToLock = postProcessor.getDocumentIdsToLock(lockingEvent);
652 if (documentIdsToLock != null && !documentIdsToLock.isEmpty()) {
653 for (String documentId : documentIdsToLock) {
654 if ( LOG.isInfoEnabled() ) {
655 LOG.info("Aquiring additional lock on document " + documentId);
656 }
657 getRouteHeaderService().lockRouteHeader(documentId);
658 if ( LOG.isInfoEnabled() ) {
659 LOG.info("Aquired lock on document " + documentId);
660 }
661 }
662 }
663 }
664
665
666
667
668
669 private DocumentRouteHeaderValue notifyPostProcessorAfterProcess(DocumentRouteHeaderValue document, String nodeInstanceId, boolean successfullyProcessed) {
670 if (document == null) {
671
672 return null;
673 }
674 return notifyPostProcessorAfterProcess(document, nodeInstanceId, new AfterProcessEvent(document.getDocumentId(),document.getAppDocId(),nodeInstanceId,successfullyProcessed));
675 }
676
677
678
679
680
681 private DocumentRouteHeaderValue notifyPostProcessorAfterProcess(DocumentRouteHeaderValue document, String nodeInstanceId, AfterProcessEvent event) {
682 ProcessDocReport report = null;
683 try {
684 PostProcessor postProcessor = null;
685
686 if (!isRunPostProcessorLogic()) {
687 postProcessor = new DefaultPostProcessor();
688 } else {
689 postProcessor = document.getDocumentType().getPostProcessor();
690 }
691 report = postProcessor.afterProcess(event);
692 } catch (Exception e) {
693 throw new RouteManagerException("Problems contacting PostProcessor.",e);
694 }
695 document = getRouteHeaderService().getRouteHeader(document.getDocumentId());
696 if (!report.isSuccess()) {
697 LOG.error("PostProcessor rejected route level change::" + report.getMessage(), report.getProcessException());
698 throw new RouteManagerException("Route Level change failed in post processor::" + report.getMessage());
699 }
700 return document;
701 }
702
703
704
705
706
707 public void initializeDocument(DocumentRouteHeaderValue document) {
708
709
710
711
712
713
714 RouteContext context = new RouteContext();
715 context.setDocument(document);
716
717 if (context.getEngineState() == null) {
718 context.setEngineState(new EngineState());
719 }
720
721 ProcessDefinitionBo process = document.getDocumentType().getPrimaryProcess();
722
723 if (process == null) {
724 throw new IllegalDocumentTypeException("DocumentType '" + document.getDocumentType().getName() + "' has no primary process configured!");
725 }
726
727 if (process.getInitialRouteNode() != null) {
728 RouteNodeInstance nodeInstance = helper.getNodeFactory().createRouteNodeInstance(document.getDocumentId(), process.getInitialRouteNode());
729 nodeInstance.setActive(true);
730 Branch branch = helper.getNodeFactory().createBranch(KewApiConstants.PRIMARY_BRANCH_NAME, null, nodeInstance);
731 nodeInstance = saveNode(context, nodeInstance);
732 document.getInitialRouteNodeInstances().add(nodeInstance);
733 }
734 }
735
736 private boolean isRunawayProcessDetected(EngineState engineState) throws NumberFormatException {
737 String maxNodesConstant = getParameterService().getParameterValueAsString(KewApiConstants.KEW_NAMESPACE, KRADConstants.DetailTypes.ALL_DETAIL_TYPE, KewApiConstants.MAX_NODES_BEFORE_RUNAWAY_PROCESS);
738 int maxNodes = (org.apache.commons.lang.StringUtils.isEmpty(maxNodesConstant)) ? 50 : Integer.valueOf(maxNodesConstant);
739 return engineState.getCompleteNodeInstances().size() > maxNodes;
740 }
741
742 protected RouteNodeService getRouteNodeService() {
743 return routeNodeService;
744 }
745
746 protected RouteHeaderService getRouteHeaderService() {
747 return routeHeaderService;
748 }
749
750 protected ParameterService getParameterService() {
751 if (parameterService == null) {
752 parameterService = CoreFrameworkServiceLocator.getParameterService();
753 }
754 return parameterService;
755 }
756
757 public void setRouteNodeService(RouteNodeService routeNodeService) {
758 this.routeNodeService = routeNodeService;
759 }
760
761 public void setRouteHeaderService(RouteHeaderService routeHeaderService) {
762 this.routeHeaderService = routeHeaderService;
763 }
764
765 public void setParameterService(ParameterService parameterService) {
766 this.parameterService = parameterService;
767 }
768 }