001: /* ExecutionAdministrationEJBBean.java */
002: package org.enhydra.shark.ws;
003:
004: import javax.naming.InitialContext;
005: import javax.transaction.Status;
006: import javax.transaction.UserTransaction;
007:
008: import org.enhydra.shark.Shark;
009: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstance;
010: import org.enhydra.shark.api.client.wfmc.wapi.WMActivityInstanceIterator;
011: import org.enhydra.shark.api.client.wfmc.wapi.WMFilter;
012: import org.enhydra.shark.api.client.wfmc.wapi.WMProcessInstanceIterator;
013: import org.enhydra.shark.api.client.wfmc.wapi.WMSessionHandle;
014: import org.enhydra.shark.api.client.wfservice.ExecutionAdministration;
015: import org.enhydra.shark.api.client.wfservice.WMEntity;
016: import org.enhydra.shark.ejb.SharkEJBUtilities;
017:
018: /**
019: * @author Sasa Bojanic
020: * @author Vladimir Puskas
021: * @author T.Jovanovic
022: * @version 0.1
023: */
024: public class ExecutionAdministrationWrapper implements
025: ExecutionAdministration {
026:
027: /**
028: * @ejb:interface-method view-type="all"
029: */
030: public void startActivity(WMSessionHandle shandle, String procId,
031: String blockActId, WMEntity actDef) throws Exception {
032: if (SharkEJBUtilities.getEnvType() == 1) {
033: UserTransaction t = null;
034: try {
035: t = (UserTransaction) new InitialContext()
036: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
037: t.begin();
038: getSharkObject().startActivity(shandle, procId,
039: blockActId, actDef);
040: t.commit();
041:
042: } catch (Exception ex) {
043: try {
044: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
045: t.rollback();
046: } catch (Exception ex1) {
047: ex1.printStackTrace();
048: }
049: throw ex;
050: }
051:
052: } else {
053: getSharkObject().startActivity(shandle, procId, blockActId,
054: actDef);
055: }
056: }
057:
058: /**
059: * @ejb:interface-method view-type="all"
060: */
061: public WMActivityInstanceIterator reevaluateAssignmentsWithFiltering(
062: WMSessionHandle shandle, WMFilter procOrActFilter,
063: boolean returnChangedOnly) throws Exception {
064: if (SharkEJBUtilities.getEnvType() == 1) {
065: UserTransaction t = null;
066: WMActivityInstanceIterator retVal = null;
067: try {
068: t = (UserTransaction) new InitialContext()
069: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
070: t.begin();
071: retVal = getSharkObject()
072: .reevaluateAssignmentsWithFiltering(shandle,
073: procOrActFilter, returnChangedOnly);
074: t.commit();
075:
076: } catch (Exception ex) {
077: try {
078: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
079: t.rollback();
080: } catch (Exception ex1) {
081: ex1.printStackTrace();
082: }
083: throw ex;
084: }
085:
086: return retVal;
087: } else {
088: return getSharkObject().reevaluateAssignmentsWithFiltering(
089: shandle, procOrActFilter, returnChangedOnly);
090: }
091: }
092:
093: /**
094: * @ejb:interface-method view-type="all"
095: */
096: public WMActivityInstanceIterator reevaluateAssignmentsForProcesses(
097: WMSessionHandle shandle, String[] procIds,
098: boolean returnChangedOnly) throws Exception {
099: if (SharkEJBUtilities.getEnvType() == 1) {
100: UserTransaction t = null;
101: WMActivityInstanceIterator retVal = null;
102: try {
103: t = (UserTransaction) new InitialContext()
104: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
105: t.begin();
106: retVal = getSharkObject()
107: .reevaluateAssignmentsForProcesses(shandle,
108: procIds, returnChangedOnly);
109: t.commit();
110:
111: } catch (Exception ex) {
112: try {
113: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
114: t.rollback();
115: } catch (Exception ex1) {
116: ex1.printStackTrace();
117: }
118: throw ex;
119: }
120:
121: return retVal;
122: } else {
123: return getSharkObject().reevaluateAssignmentsForProcesses(
124: shandle, procIds, returnChangedOnly);
125: }
126: }
127:
128: /**
129: * @ejb:interface-method view-type="all"
130: */
131: public WMActivityInstanceIterator reevaluateAssignmentsForActivities(
132: WMSessionHandle shandle, WMActivityInstance[] acts,
133: boolean returnChangedOnly) throws Exception {
134: if (SharkEJBUtilities.getEnvType() == 1) {
135: UserTransaction t = null;
136: WMActivityInstanceIterator retVal = null;
137: try {
138: t = (UserTransaction) new InitialContext()
139: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
140: t.begin();
141: retVal = getSharkObject()
142: .reevaluateAssignmentsForActivities(shandle,
143: acts, returnChangedOnly);
144: t.commit();
145:
146: } catch (Exception ex) {
147: try {
148: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
149: t.rollback();
150: } catch (Exception ex1) {
151: ex1.printStackTrace();
152: }
153: throw ex;
154: }
155:
156: return retVal;
157: } else {
158: return getSharkObject().reevaluateAssignmentsForActivities(
159: shandle, acts, returnChangedOnly);
160: }
161: }
162:
163: /**
164: * @ejb:interface-method view-type="all"
165: */
166: public WMProcessInstanceIterator deleteProcessesWithFiltering(
167: WMSessionHandle shandle, WMFilter procFilter)
168: throws Exception {
169: if (SharkEJBUtilities.getEnvType() == 1) {
170: UserTransaction t = null;
171: WMProcessInstanceIterator retVal = null;
172: try {
173: t = (UserTransaction) new InitialContext()
174: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
175: t.begin();
176: retVal = getSharkObject().deleteProcessesWithFiltering(
177: shandle, procFilter);
178: t.commit();
179:
180: } catch (Exception ex) {
181: try {
182: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
183: t.rollback();
184: } catch (Exception ex1) {
185: ex1.printStackTrace();
186: }
187: throw ex;
188: }
189:
190: return retVal;
191: } else {
192: return getSharkObject().deleteProcessesWithFiltering(
193: shandle, procFilter);
194: }
195: }
196:
197: /**
198: * @ejb:interface-method view-type="all"
199: */
200: public WMProcessInstanceIterator deleteProcesses(
201: WMSessionHandle shandle, String[] procIds) throws Exception {
202: if (SharkEJBUtilities.getEnvType() == 1) {
203: UserTransaction t = null;
204: WMProcessInstanceIterator retVal = null;
205: try {
206: t = (UserTransaction) new InitialContext()
207: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
208: t.begin();
209: retVal = getSharkObject().deleteProcesses(shandle,
210: procIds);
211: t.commit();
212:
213: } catch (Exception ex) {
214: try {
215: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
216: t.rollback();
217: } catch (Exception ex1) {
218: ex1.printStackTrace();
219: }
220: throw ex;
221: }
222:
223: return retVal;
224: } else {
225: return getSharkObject().deleteProcesses(shandle, procIds);
226: }
227: }
228:
229: /**
230: * @ejb:interface-method view-type="all"
231: */
232: public void injectException(WMSessionHandle shandle, String procId,
233: String actId, Exception ex) throws Exception {
234:
235: if (SharkEJBUtilities.getEnvType() == 1) {
236: UserTransaction t = null;
237: try {
238: t = (UserTransaction) new InitialContext()
239: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
240: t.begin();
241: getSharkObject().injectException(shandle, procId,
242: actId, ex);
243: t.commit();
244:
245: } catch (Exception ex1) {
246: try {
247: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
248: t.rollback();
249: } catch (Exception ex2) {
250: ex2.printStackTrace();
251: }
252: throw ex;
253: }
254: } else {
255: getSharkObject()
256: .injectException(shandle, procId, actId, ex);
257: }
258: }
259:
260: /**
261: * @ejb:interface-method view-type="all"
262: */
263: public void assignProcessInstanceProperty(WMSessionHandle shandle,
264: String procInstId, String propName, Object propValue)
265: throws Exception {
266: if (SharkEJBUtilities.getEnvType() == 1) {
267: UserTransaction t = null;
268: try {
269: t = (UserTransaction) new InitialContext()
270: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
271: t.begin();
272: getSharkObject().assignProcessInstanceProperty(shandle,
273: procInstId, propName, propValue);
274: t.commit();
275:
276: } catch (Exception ex) {
277: try {
278: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
279: t.rollback();
280: } catch (Exception ex1) {
281: ex1.printStackTrace();
282: }
283: throw ex;
284: }
285:
286: } else {
287: getSharkObject().assignProcessInstanceProperty(shandle,
288: procInstId, propName, propValue);
289: }
290:
291: }
292:
293: /**
294: * @ejb:interface-method view-type="all"
295: */
296: public void assignActivityInstanceProperty(WMSessionHandle shandle,
297: String procInstId, String actInstId, String propName,
298: Object propValue) throws Exception {
299: if (SharkEJBUtilities.getEnvType() == 1) {
300: UserTransaction t = null;
301: try {
302: t = (UserTransaction) new InitialContext()
303: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
304: t.begin();
305: getSharkObject().assignActivityInstanceProperty(
306: shandle, procInstId, actInstId, propName,
307: propValue);
308: t.commit();
309:
310: } catch (Exception ex) {
311: try {
312: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
313: t.rollback();
314: } catch (Exception ex1) {
315: ex1.printStackTrace();
316: }
317: throw ex;
318: }
319:
320: } else {
321: getSharkObject().assignActivityInstanceProperty(shandle,
322: procInstId, actInstId, propName, propValue);
323: }
324: }
325:
326: /**
327: * @ejb:interface-method view-type="all"
328: */
329: public void assignActivityInstanceAttributeForLocalContext(
330: WMSessionHandle shandle, String procInstId,
331: String actInstId, String attrName, Object attrValue)
332: throws Exception {
333: if (SharkEJBUtilities.getEnvType() == 1) {
334: UserTransaction t = null;
335: try {
336: t = (UserTransaction) new InitialContext()
337: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
338: t.begin();
339: getSharkObject()
340: .assignActivityInstanceAttributeForLocalContext(
341: shandle, procInstId, actInstId,
342: attrName, attrValue);
343: t.commit();
344:
345: } catch (Exception ex) {
346: try {
347: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
348: t.rollback();
349: } catch (Exception ex1) {
350: ex1.printStackTrace();
351: }
352: throw ex;
353: }
354:
355: } else {
356: getSharkObject()
357: .assignActivityInstanceAttributeForLocalContext(
358: shandle, procInstId, actInstId, attrName,
359: attrValue);
360: }
361: }
362:
363: // /////////////////////// CACHEADMIN
364:
365: /**
366: * @ejb:interface-method view-type="all"
367: */
368: public void setProcessCacheSize(WMSessionHandle shandle, int size)
369: throws Exception {
370: if (SharkEJBUtilities.getEnvType() == 1) {
371: UserTransaction t = null;
372:
373: try {
374: t = (UserTransaction) new InitialContext()
375: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
376: t.begin();
377: getSharkObject().setProcessCacheSize(shandle, size);
378: t.commit();
379:
380: } catch (Exception ex) {
381: try {
382: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
383: t.rollback();
384: } catch (Exception ex1) {
385: ex1.printStackTrace();
386: }
387: throw ex;
388: }
389:
390: } else {
391: getSharkObject().setProcessCacheSize(shandle, size);
392: }
393: }
394:
395: /**
396: * @ejb:interface-method view-type="all"
397: */
398: public void clearProcessCache(WMSessionHandle shandle)
399: throws Exception {
400: if (SharkEJBUtilities.getEnvType() == 1) {
401: UserTransaction t = null;
402: try {
403: t = (UserTransaction) new InitialContext()
404: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
405: t.begin();
406: getSharkObject().clearProcessCache(shandle);
407: t.commit();
408:
409: } catch (Exception ex) {
410: try {
411: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
412: t.rollback();
413: } catch (Exception ex1) {
414: ex1.printStackTrace();
415: }
416: throw ex;
417: }
418: } else {
419: getSharkObject().clearProcessCache(shandle);
420: }
421: }
422:
423: /**
424: * @ejb:interface-method view-type="all"
425: */
426: public void setResourceCacheSize(WMSessionHandle shandle, int size)
427: throws Exception {
428: if (SharkEJBUtilities.getEnvType() == 1) {
429: UserTransaction t = null;
430: try {
431: t = (UserTransaction) new InitialContext()
432: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
433: t.begin();
434: getSharkObject().setResourceCacheSize(shandle, size);
435: t.commit();
436:
437: } catch (Exception ex) {
438: try {
439: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
440: t.rollback();
441: } catch (Exception ex1) {
442: ex1.printStackTrace();
443: }
444: throw ex;
445: }
446: } else {
447: getSharkObject().setResourceCacheSize(shandle, size);
448: }
449: }
450:
451: /**
452: * @ejb:interface-method view-type="all"
453: */
454: public void clearResourceCache(WMSessionHandle shandle)
455: throws Exception {
456: if (SharkEJBUtilities.getEnvType() == 1) {
457: UserTransaction t = null;
458: try {
459: t = (UserTransaction) new InitialContext()
460: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
461: t.begin();
462: getSharkObject().clearResourceCache(shandle);
463: t.commit();
464:
465: } catch (Exception ex) {
466: try {
467: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
468: t.rollback();
469: } catch (Exception ex1) {
470: ex1.printStackTrace();
471: }
472: throw ex;
473: }
474: } else {
475: getSharkObject().clearResourceCache(shandle);
476: }
477: }
478:
479: // /////////////////////// DEADLINE
480:
481: /**
482: * @ejb:interface-method view-type="all"
483: */
484: public String[] getDeadlineRichedProcessIds(WMSessionHandle shandle)
485: throws Exception {
486: if (SharkEJBUtilities.getEnvType() == 1) {
487: UserTransaction t = null;
488: String[] retVal = null;
489: try {
490: t = (UserTransaction) new InitialContext()
491: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
492: t.begin();
493: retVal = getSharkObject().getDeadlineRichedProcessIds(
494: shandle);
495: t.commit();
496:
497: } catch (Exception ex) {
498: try {
499: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
500: t.rollback();
501: } catch (Exception ex1) {
502: ex1.printStackTrace();
503: }
504: throw ex;
505: }
506:
507: return retVal;
508: } else {
509: return getSharkObject()
510: .getDeadlineRichedProcessIds(shandle);
511: }
512: }
513:
514: /**
515: * @ejb:interface-method view-type="all"
516: */
517: public WMActivityInstanceIterator checkDeadlinesWithFiltering(
518: WMSessionHandle shandle, WMFilter procOrActFilter)
519: throws Exception {
520: if (SharkEJBUtilities.getEnvType() == 1) {
521: UserTransaction t = null;
522: WMActivityInstanceIterator retVal = null;
523: try {
524: t = (UserTransaction) new InitialContext()
525: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
526: t.begin();
527: retVal = getSharkObject().checkDeadlinesWithFiltering(
528: shandle, procOrActFilter);
529: t.commit();
530:
531: } catch (Exception ex) {
532: try {
533: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
534: t.rollback();
535: } catch (Exception ex1) {
536: ex1.printStackTrace();
537: }
538: throw ex;
539: }
540:
541: return retVal;
542: } else {
543: return getSharkObject().checkDeadlinesWithFiltering(
544: shandle, procOrActFilter);
545: }
546: }
547:
548: /**
549: * @ejb:interface-method view-type="all"
550: */
551: public WMActivityInstanceIterator checkDeadlinesForProcesses(
552: WMSessionHandle shandle, String[] procIds) throws Exception {
553: if (SharkEJBUtilities.getEnvType() == 1) {
554: UserTransaction t = null;
555: WMActivityInstanceIterator retVal = null;
556: try {
557: t = (UserTransaction) new InitialContext()
558: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
559: t.begin();
560: retVal = getSharkObject().checkDeadlinesForProcesses(
561: shandle, procIds);
562: t.commit();
563:
564: } catch (Exception ex) {
565: try {
566: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
567: t.rollback();
568: } catch (Exception ex1) {
569: ex1.printStackTrace();
570: }
571: throw ex;
572: }
573:
574: return retVal;
575: } else {
576: return getSharkObject().checkDeadlinesForProcesses(shandle,
577: procIds);
578: }
579: }
580:
581: /**
582: * @ejb:interface-method view-type="all"
583: */
584: public WMActivityInstanceIterator checkDeadlinesForActivities(
585: WMSessionHandle session, WMActivityInstance[] acts)
586: throws Exception {
587: if (SharkEJBUtilities.getEnvType() == 1) {
588: UserTransaction t = null;
589: WMActivityInstanceIterator retVal = null;
590: try {
591: t = (UserTransaction) new InitialContext()
592: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
593: t.begin();
594: retVal = getSharkObject().checkDeadlinesForActivities(
595: session, acts);
596: t.commit();
597:
598: } catch (Exception ex) {
599: try {
600: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
601: t.rollback();
602: } catch (Exception ex1) {
603: ex1.printStackTrace();
604: }
605: throw ex;
606: }
607:
608: return retVal;
609: } else {
610: return getSharkObject().checkDeadlinesForActivities(
611: session, acts);
612: }
613: }
614:
615: // /////////////////////// LIMIT
616:
617: /**
618: * @ejb:interface-method view-type="all"
619: */
620: public WMProcessInstanceIterator checkLimitsWithProcessFiltering(
621: WMSessionHandle sessionHandle, WMFilter procFilter,
622: boolean checkActivities) throws Exception {
623: if (SharkEJBUtilities.getEnvType() == 1) {
624: UserTransaction t = null;
625: WMProcessInstanceIterator retVal = null;
626: try {
627: t = (UserTransaction) new InitialContext()
628: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
629: t.begin();
630: retVal = getSharkObject()
631: .checkLimitsWithProcessFiltering(sessionHandle,
632: procFilter, checkActivities);
633: t.commit();
634:
635: } catch (Exception ex) {
636: try {
637: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
638: t.rollback();
639: } catch (Exception ex1) {
640: ex1.printStackTrace();
641: }
642: throw ex;
643: }
644:
645: return retVal;
646: } else {
647: return getSharkObject().checkLimitsWithProcessFiltering(
648: sessionHandle, procFilter, checkActivities);
649: }
650: }
651:
652: /**
653: * @ejb:interface-method view-type="all"
654: */
655: public WMProcessInstanceIterator checkLimitsForProcesses(
656: WMSessionHandle sessionHandle, String[] procIds,
657: boolean checkActivities) throws Exception {
658: if (SharkEJBUtilities.getEnvType() == 1) {
659: UserTransaction t = null;
660: WMProcessInstanceIterator retVal = null;
661: try {
662: t = (UserTransaction) new InitialContext()
663: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
664: t.begin();
665: retVal = getSharkObject().checkLimitsForProcesses(
666: sessionHandle, procIds, checkActivities);
667: t.commit();
668:
669: } catch (Exception ex) {
670: try {
671: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
672: t.rollback();
673: } catch (Exception ex1) {
674: ex1.printStackTrace();
675: }
676: throw ex;
677: }
678:
679: return retVal;
680: } else {
681: return getSharkObject().checkLimitsForProcesses(
682: sessionHandle, procIds, checkActivities);
683: }
684: }
685:
686: /**
687: * @ejb:interface-method view-type="all"
688: */
689: public WMActivityInstanceIterator checkLimitsWithActivityFiltering(
690: WMSessionHandle sessionHandle, WMFilter actFilter)
691: throws Exception {
692: if (SharkEJBUtilities.getEnvType() == 1) {
693: UserTransaction t = null;
694: WMActivityInstanceIterator retVal = null;
695: try {
696: t = (UserTransaction) new InitialContext()
697: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
698: t.begin();
699: retVal = getSharkObject()
700: .checkLimitsWithActivityFiltering(
701: sessionHandle, actFilter);
702: t.commit();
703:
704: } catch (Exception ex) {
705: try {
706: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
707: t.rollback();
708: } catch (Exception ex1) {
709: ex1.printStackTrace();
710: }
711: throw ex;
712: }
713:
714: return retVal;
715: } else {
716: return getSharkObject().checkLimitsWithActivityFiltering(
717: sessionHandle, actFilter);
718: }
719: }
720:
721: /**
722: * @ejb:interface-method view-type="all"
723: */
724: public WMActivityInstanceIterator checkLimitsForActivities(
725: WMSessionHandle sessionHandle, WMActivityInstance[] acts)
726: throws Exception {
727: if (SharkEJBUtilities.getEnvType() == 1) {
728: UserTransaction t = null;
729: WMActivityInstanceIterator retVal = null;
730: try {
731: t = (UserTransaction) new InitialContext()
732: .lookup(SharkEJBUtilities.TOMCAT_USER_TRANS_JNDI_NAME);
733: t.begin();
734: retVal = getSharkObject().checkLimitsForActivities(
735: sessionHandle, acts);
736: t.commit();
737:
738: } catch (Exception ex) {
739: try {
740: if (t.getStatus() != Status.STATUS_NO_TRANSACTION)
741: t.rollback();
742: } catch (Exception ex1) {
743: ex1.printStackTrace();
744: }
745: throw ex;
746: }
747:
748: return retVal;
749: } else {
750: return getSharkObject().checkLimitsForActivities(
751: sessionHandle, acts);
752: }
753: }
754:
755: protected ExecutionAdministration getSharkObject() throws Exception {
756: return (ExecutionAdministration) Shark.getInstance()
757: .getExecutionAdministration();
758: }
759: }
|