Java > Open Source Codes > org > enhydra > shark > SharkUtilities


1 package org.enhydra.shark;
2
3 import java.io.File ;
4 import java.io.FileFilter ;
5 import java.text.DateFormat ;
6 import java.text.ParseException ;
7 import java.util.ArrayList ;
8 import java.util.Arrays ;
9 import java.util.Collection ;
10 import java.util.Collections ;
11 import java.util.Date ;
12 import java.util.HashMap ;
13 import java.util.HashSet ;
14 import java.util.Iterator ;
15 import java.util.List ;
16 import java.util.Map ;
17 import java.util.Set ;
18
19 import org.enhydra.shark.api.ApplicationMappingTransaction;
20 import org.enhydra.shark.api.ParticipantMappingTransaction;
21 import org.enhydra.shark.api.RepositoryTransaction;
22 import org.enhydra.shark.api.RootError;
23 import org.enhydra.shark.api.RootException;
24 import org.enhydra.shark.api.ScriptMappingTransaction;
25 import org.enhydra.shark.api.SharkTransaction;
26 import org.enhydra.shark.api.TransactionException;
27 import org.enhydra.shark.api.UserTransaction;
28 import org.enhydra.shark.api.client.wfbase.BaseException;
29 import org.enhydra.shark.api.client.wfmodel.WfAssignment;
30 import org.enhydra.shark.api.common.SharkConstants;
31 import org.enhydra.shark.api.internal.appmappersistence.ApplicationMappingManager;
32 import org.enhydra.shark.api.internal.assignment.AssignmentManager;
33 import org.enhydra.shark.api.internal.assignment.PerformerData;
34 import org.enhydra.shark.api.internal.authentication.AuthenticationManager;
35 import org.enhydra.shark.api.internal.caching.CacheMgr;
36 import org.enhydra.shark.api.internal.caching.ProcessCache;
37 import org.enhydra.shark.api.internal.caching.ResourceCache;
38 import org.enhydra.shark.api.internal.eventaudit.AssignmentEventAuditPersistenceInterface;
39 import org.enhydra.shark.api.internal.eventaudit.CreateProcessEventAuditPersistenceInterface;
40 import org.enhydra.shark.api.internal.eventaudit.DataEventAuditPersistenceInterface;
41 import org.enhydra.shark.api.internal.eventaudit.EventAuditManagerInterface;
42 import org.enhydra.shark.api.internal.eventaudit.EventAuditPersistenceInterface;
43 import org.enhydra.shark.api.internal.eventaudit.StateEventAuditPersistenceInterface;
44 import org.enhydra.shark.api.internal.instancepersistence.AssignmentPersistenceInterface;
45 import org.enhydra.shark.api.internal.instancepersistence.PersistenceException;
46 import org.enhydra.shark.api.internal.instancepersistence.PersistentManagerInterface;
47 import org.enhydra.shark.api.internal.instancepersistence.ProcessMgrPersistenceInterface;
48 import org.enhydra.shark.api.internal.instancepersistence.ProcessPersistenceInterface;
49 import org.enhydra.shark.api.internal.instancepersistence.ResourcePersistenceInterface;
50 import org.enhydra.shark.api.internal.partmappersistence.ParticipantMappingManager;
51 import org.enhydra.shark.api.internal.processlocking.LockMaster;
52 import org.enhydra.shark.api.internal.repositorypersistence.RepositoryPersistenceManager;
53 import org.enhydra.shark.api.internal.scripting.Evaluator;
54 import org.enhydra.shark.api.internal.scriptmappersistence.ScriptMappingManager;
55 import org.enhydra.shark.api.internal.security.SecurityManager;
56 import org.enhydra.shark.api.internal.toolagent.ToolAgentGeneralException;
57 import org.enhydra.shark.api.internal.transaction.SharkInternalTransaction;
58 import org.enhydra.shark.api.internal.transaction.TransactionFactory;
59 import org.enhydra.shark.api.internal.usertransaction.UserTransactionFactory;
60 import org.enhydra.shark.api.internal.working.CallbackUtilities;
61 import org.enhydra.shark.api.internal.working.ObjectFactory;
62 import org.enhydra.shark.api.internal.working.WfActivityInternal;
63 import org.enhydra.shark.api.internal.working.WfAssignmentInternal;
64 import org.enhydra.shark.api.internal.working.WfProcessInternal;
65 import org.enhydra.shark.api.internal.working.WfProcessMgrInternal;
66 import org.enhydra.shark.api.internal.working.WfResourceInternal;
67 import org.enhydra.shark.utilities.MiscUtilities;
68 import org.enhydra.shark.utilities.SequencedHashMap;
69 import org.enhydra.shark.xpdl.Version;
70 import org.enhydra.shark.xpdl.XMLCollectionElement;
71 import org.enhydra.shark.xpdl.XMLElement;
72 import org.enhydra.shark.xpdl.XMLInterface;
73 import org.enhydra.shark.xpdl.XMLInterfaceForJDK13;
74 import org.enhydra.shark.xpdl.XMLUtil;
75 import org.enhydra.shark.xpdl.XPDLConstants;
76 import org.enhydra.shark.xpdl.elements.Activities;
77 import org.enhydra.shark.xpdl.elements.Activity;
78 import org.enhydra.shark.xpdl.elements.ActivitySet;
79 import org.enhydra.shark.xpdl.elements.ActualParameter;
80 import org.enhydra.shark.xpdl.elements.ActualParameters;
81 import org.enhydra.shark.xpdl.elements.Application;
82 import org.enhydra.shark.xpdl.elements.BlockActivity;
83 import org.enhydra.shark.xpdl.elements.DataField;
84 import org.enhydra.shark.xpdl.elements.DataFields;
85 import org.enhydra.shark.xpdl.elements.DataType;
86 import org.enhydra.shark.xpdl.elements.ExtendedAttribute;
87 import org.enhydra.shark.xpdl.elements.ExtendedAttributes;
88 import org.enhydra.shark.xpdl.elements.ExternalPackage;
89 import org.enhydra.shark.xpdl.elements.FormalParameter;
90 import org.enhydra.shark.xpdl.elements.FormalParameters;
91 import org.enhydra.shark.xpdl.elements.Package;
92 import org.enhydra.shark.xpdl.elements.Participant;
93 import org.enhydra.shark.xpdl.elements.WorkflowProcess;
94
95
96 /**
97  * The various utilities needed for shark.
98  * @author Sasa Bojanic
99  * @author Vladimir Puskas
100  * @author Zoran Milakovic
101  */
102 public class SharkUtilities {
103    // TODO: implement Enumeration type handling
104 // TODO: if some data from XPDL Package are wanted, sometimes
105 // they are not retrieved (i.e. if one asks for variable name, and
106 // the variable's XPDL is not cached -> exception happens)
107
108    private static Map validActivityStates=new HashMap ();
109    static {
110       List vsList=new ArrayList ();
111       validActivityStates.put(SharkConstants.STATE_CLOSED_ABORTED,vsList);
112       validActivityStates.put(SharkConstants.STATE_CLOSED_COMPLETED,vsList);
113       validActivityStates.put(SharkConstants.STATE_CLOSED_TERMINATED,vsList);
114
115       vsList=new ArrayList (SharkConstants.possibleActivityStates);
116       vsList.remove(SharkConstants.STATE_OPEN_RUNNING);
117       validActivityStates.put(SharkConstants.STATE_OPEN_RUNNING,vsList);
118
119       vsList=new ArrayList (SharkConstants.possibleActivityStates);
120       vsList.remove(SharkConstants.STATE_OPEN_NOT_RUNNING_NOT_STARTED);
121       vsList.remove(SharkConstants.STATE_CLOSED_COMPLETED);
122       validActivityStates.put(SharkConstants.STATE_OPEN_NOT_RUNNING_NOT_STARTED,vsList);
123
124       vsList=new ArrayList (SharkConstants.possibleActivityStates);
125       vsList.remove(SharkConstants.STATE_OPEN_NOT_RUNNING_SUSPENDED);
126       vsList.remove(SharkConstants.STATE_CLOSED_COMPLETED);
127       validActivityStates.put(SharkConstants.STATE_OPEN_NOT_RUNNING_SUSPENDED,vsList);
128    }
129
130    static final List valid_activity_states (String currentState) {
131       return (List )validActivityStates.get(currentState);
132    }
133
134
135
136    private static Map validProcessStates=new HashMap ();
137    static {
138       List vsList=new ArrayList ();
139       validProcessStates.put(SharkConstants.STATE_CLOSED_ABORTED,vsList);
140       validProcessStates.put(SharkConstants.STATE_CLOSED_COMPLETED,vsList);
141       validProcessStates.put(SharkConstants.STATE_CLOSED_TERMINATED,vsList);
142
143       vsList=new ArrayList (SharkConstants.possibleProcessStates);
144       vsList.remove(SharkConstants.STATE_OPEN_RUNNING);
145       vsList.remove(SharkConstants.STATE_OPEN_NOT_RUNNING_NOT_STARTED);
146       validProcessStates.put(SharkConstants.STATE_OPEN_RUNNING,vsList);
147
148       vsList=new ArrayList (SharkConstants.possibleProcessStates);
149       vsList.remove(SharkConstants.STATE_OPEN_NOT_RUNNING_NOT_STARTED);
150       vsList.remove(SharkConstants.STATE_OPEN_NOT_RUNNING_SUSPENDED);
151       vsList.remove(SharkConstants.STATE_CLOSED_COMPLETED);
152       validProcessStates.put(SharkConstants.STATE_OPEN_NOT_RUNNING_NOT_STARTED,vsList);
153
154       vsList=new ArrayList (SharkConstants.possibleProcessStates);
155       vsList.remove(SharkConstants.STATE_OPEN_NOT_RUNNING_SUSPENDED);
156       vsList.remove(SharkConstants.STATE_CLOSED_COMPLETED);
157       validProcessStates.put(SharkConstants.STATE_OPEN_NOT_RUNNING_SUSPENDED,vsList);
158    }
159
160    static final List valid_process_states (String currentState) {
161       return (List )validProcessStates.get(currentState);
162    }
163
164    // The locations to various repositories
165 public static final String EXTERNAL_PACKAGES_REPOSITORY=
166       SharkUtilities.getRepository("EXTERNAL_PACKAGES_REPOSITORY");
167
168    // counts connections to engine
169 private static int nextConnectionKey=1;
170    static synchronized String getNextConnectionKey(){
171       String ck= Integer.toString(nextConnectionKey);
172       nextConnectionKey++;
173       return ck;
174    }
175
176    // a cache of loaded objects
177 private static Map loggedUsers=new SequencedHashMap();
178
179    private static Map currentPkgVersions=new HashMap ();
180
181    private static PackageFileFilter packageFileFilter=new PackageFileFilter();
182
183    static String connect (String userId) {
184       String connectionKey=getNextConnectionKey();
185       loggedUsers.put(connectionKey,userId);
186       return connectionKey;
187    }
188
189    static void disconnect (String connectionKey) {
190       loggedUsers.remove(connectionKey);
191    }
192
193    static Map getLoggedUsers () throws Exception {
194       return Collections.unmodifiableMap(loggedUsers);
195    }
196
197    static List getDefinedPackageFiles (String repository,boolean traverse) {
198       File startingFolder=new File (repository);
199       List packageFiles=new ArrayList ();
200       if (!startingFolder.exists()) {
201          SharkEngineManager.getInstance().getCallbackUtilities().warn("SharkUtilities -> Repository "+startingFolder+" doesn't exist");
202       }
203       if (traverse) {
204          MiscUtilities.traverse(startingFolder,packageFiles,null);
205       } else {
206          packageFiles=Arrays.asList(startingFolder.listFiles(packageFileFilter));
207       }
208       return packageFiles;
209    }
210
211
212    static String convertToAbsolutePath (String relativePathToPackage) {
213       String absolutePath=relativePathToPackage;
214       List packageFiles=SharkUtilities.getDefinedPackageFiles(EXTERNAL_PACKAGES_REPOSITORY,true);
215       String dirName= new File (EXTERNAL_PACKAGES_REPOSITORY)
216          .getAbsolutePath();
217       Iterator pfi=packageFiles.iterator();
218       while (pfi.hasNext()) {
219          File f=(File )pfi.next();
220          String fileName=f.getAbsolutePath();
221          fileName=fileName.substring(dirName.length()+1);
222          if (fileName.equals(relativePathToPackage)) {
223             absolutePath=f.getAbsolutePath();
224             break;
225          }
226       }
227       return absolutePath;
228    }
229
230
231
232
233    static List createAllProcessMgrWrappers (SharkTransaction t,String userAuth) throws BaseException {
234       try {
235          List mgrs=new ArrayList ();
236          List l=SharkEngineManager
237             .getInstance()
238             .getInstancePersistenceManager()
239             .getAllProcessMgrs(t);
240          for (int i=0; i<l.size(); i++) {
241             ProcessMgrPersistenceInterface po=(ProcessMgrPersistenceInterface)l.get(i);
242             mgrs.add(SharkEngineManager.getInstance().getObjectFactory().createProcessMgrWrapper(userAuth,po.getName()));
243          }
244          return mgrs;
245       } catch (Exception ex) {
246          throw new BaseException(ex);
247       }
248    }
249
250    static List createProcessMgrsProcessWrappers (SharkTransaction t,String userAuth,String mgrName) throws BaseException {
251       try {
252          List l=SharkEngineManager.getInstance().getInstancePersistenceManager().getAllProcessesForMgr(mgrName,t);
253          List ret=new ArrayList ();
254          for (int i=0; i<l.size(); i++) {
255             ProcessPersistenceInterface po=(ProcessPersistenceInterface)l.get(i);
256             ret.add(SharkEngineManager.getInstance().getObjectFactory().createProcessWrapper(userAuth,po.getProcessMgrName(),po.getId()));
257          }
258          return ret;
259       } catch (Exception ex) {
260          throw new BaseException(ex);
261       }
262    }
263
264    static List createActivityPerformerWrapper (SharkTransaction t,String userAuth,String procId,String actId) throws BaseException {
265       WfActivityInternal act=SharkUtilities.getActivity(t,procId,actId);
266       String performerId=act.getPerformerId(t);
267       List ret=new ArrayList ();
268       if (performerId!=null) {
269          ret.add(SharkEngineManager.getInstance().getObjectFactory().createProcessWrapper(userAuth,act.manager_name(t),performerId));
270       }
271       return ret;
272    }
273
274    static List createResourceRequesterPerformersWrapper (SharkTransaction t,String userAuth,String username) throws BaseException {
275       try {
276          PersistentManagerInterface ipi=SharkEngineManager
277          .getInstance()
278          .getInstancePersistenceManager();
279          List l=ipi.getResourceRequestersProcessIds(username,t);
280          List ret=new ArrayList ();
281          for (int i=0; i<l.size(); i++) {
282             String pId=(String )l.get(i);
283             ProcessPersistenceInterface po=ipi.restoreProcess(pId, t);
284             // TODO: decide if we have to check here about external requesters
285 // (or maybe already in instance persistence layer). This is all due
286 // to a change of persisting external requesters
287 ret.add(SharkEngineManager.getInstance().getObjectFactory().createProcessWrapper(userAuth,po.getId(),po.getProcessMgrName()));
288          }
289          return ret;
290       } catch (Exception ex) {
291          throw new BaseException(ex);
292       }
293    }
294
295    static List createProcessActivityWrappers (SharkTransaction t,String userAuth,String procId) throws BaseException {
296       try {
297          WfProcessInternal proc=SharkUtilities.getProcess(t,procId);
298          List l=proc.getAllActivities(t);
299          List ret=new ArrayList ();
300          for (int i=0; i<l.size(); i++) {
301             WfActivityInternal act=(WfActivityInternal)l.get(i);
302             ret.add(SharkEngineManager.getInstance().getObjectFactory().createActivityWrapper(userAuth,proc.manager_name(t),procId,act.key(t)));
303          }
304          //System.err.println("AllProcesses for mgr "+mgr.getProcessDefinitionId()+" are "+ret);
305 return ret;
306       } catch (Exception ex) {
307          throw new BaseException(ex);
308       }
309    }
310
311    static List createAssignmentWrappers (SharkTransaction t,String userAuth,String procId,String actId) throws BaseException {
312       try {
313          List objs=SharkEngineManager
314             .getInstance()
315             .getInstancePersistenceManager()
316             .getAllValidAssignmentsForActivity(actId,t);
317
318          List pobjs=new ArrayList ();
319          for (Iterator i=objs.iterator();i.hasNext();) {
320             AssignmentPersistenceInterface po=(AssignmentPersistenceInterface)i.next();
321             pobjs.add(SharkEngineManager.getInstance().getObjectFactory().createAssignmentWrapper(userAuth,po.getProcessMgrName(),procId,actId,po.getResourceUsername()));
322          }
323          return pobjs;
324       } catch (Exception ex) {
325          throw new BaseException(ex);
326       }
327    }
328
329    static List createAssignmentWrappers (SharkTransaction t,String userAuth,String username) throws BaseException {
330       try {
331          List objs=SharkUtilities.getResource(t,username).getAssignments(t);
332          List pobjs=new ArrayList ();
333          for (Iterator i=objs.iterator();i.hasNext();) {
334             WfAssignmentInternal ass=(WfAssignmentInternal)i.next();
335             pobjs.add(SharkEngineManager.getInstance().getObjectFactory().createAssignmentWrapper(userAuth,ass.managerName(t),ass.processId(t),ass.activityId(t),username));
336          }
337          return pobjs;
338       } catch (Exception ex) {
339          throw new BaseException(ex);
340       }
341    }
342
343    static List createAllResourceWrappers (SharkTransaction t,String userAuth) throws BaseException {
344       try {
345          List resources=new ArrayList ();
346          List l=SharkEngineManager.getInstance().getInstancePersistenceManager().getAllResources(t);
347          for (int i=0; i<l.size(); i++) {
348             ResourcePersistenceInterface po=(ResourcePersistenceInterface)l.get(i);
349             resources.add(SharkEngineManager.getInstance().getObjectFactory().createResourceWrapper(userAuth,po.getUsername()));
350          }
351          return resources;
352       } catch (Exception ex) {
353          throw new BaseException(ex);
354       }
355    }
356
357    static List createProcessHistoryEvents (SharkTransaction t,String userAuth,String procId) throws BaseException {
358       List history=new ArrayList ();
359       try {
360          EventAuditManagerInterface eam = SharkEngineManager
361             .getInstance()
362             .getEventAuditManager();
363          if (null == eam)
364             return history;
365          List l = eam.restoreProcessHistory(procId, t);
366          for (int i=0; i<l.size(); i++) {
367             EventAuditPersistenceInterface audit=(EventAuditPersistenceInterface)l.get(i);
368             if (audit instanceof CreateProcessEventAuditPersistenceInterface) {
369                history.add(SharkEngineManager
370                               .getInstance()
371                               .getObjectFactory()
372                               .createCreateProcessEventAuditWrapper
373                               (userAuth,(CreateProcessEventAuditPersistenceInterface)audit));
374             } else if (audit instanceof DataEventAuditPersistenceInterface) {
375                history.add(SharkEngineManager
376                               .getInstance()
377                               .getObjectFactory()
378                               .createDataEventAuditWrapper
379                               (userAuth,(DataEventAuditPersistenceInterface)audit));
380             } else if (audit instanceof StateEventAuditPersistenceInterface) {
381                history.add(SharkEngineManager
382                               .getInstance()
383                               .getObjectFactory()
384                               .createStateEventAuditWrapper
385                               (userAuth,(StateEventAuditPersistenceInterface)audit));
386             }
387          }
388       } catch (Exception ex) {
389          throw new BaseException(ex);
390       }
391       return history;
392    }
393
394    static List createActivityHistoryEvents (SharkTransaction t,String userAuth,String procId,String actId) throws BaseException {
395       List history=new ArrayList ();
396       try {
397          EventAuditManagerInterface eam = SharkEngineManager
398             .getInstance()
399             .getEventAuditManager();
400          if (null == eam)
401             return history;
402          List l = eam.restoreActivityHistory(procId,actId,t);
403          for (int i=0; i<l.size(); i++) {
404             EventAuditPersistenceInterface audit=(EventAuditPersistenceInterface)l.get(i);
405             if (audit instanceof AssignmentEventAuditPersistenceInterface) {
406                history.add(SharkEngineManager.getInstance().
407                               getObjectFactory().createAssignmentEventAuditWrapper(userAuth,(AssignmentEventAuditPersistenceInterface)audit));
408             } else if (audit instanceof DataEventAuditPersistenceInterface) {
409                history.add(SharkEngineManager.getInstance().
410                               getObjectFactory().createDataEventAuditWrapper(userAuth,(DataEventAuditPersistenceInterface)audit));
411             } else if (audit instanceof StateEventAuditPersistenceInterface) {
412                history.add(SharkEngineManager.getInstance().
413                               getObjectFactory().createStateEventAuditWrapper(userAuth,(StateEventAuditPersistenceInterface)audit));
414             }
415          }
416          return history;
417       } catch (Exception ex) {
418          throw new BaseException(ex);
419       }
420    }
421
422    static void reevaluateAssignments (SharkTransaction t) throws BaseException {
423       try {
424          List mgrs=new ArrayList ();
425          List l=SharkEngineManager
426             .getInstance()
427             .getInstancePersistenceManager()
428             .getAllProcessMgrs(t);
429          for (int i=0; i<l.size(); i++) {
430             ProcessMgrPersistenceInterface po=(ProcessMgrPersistenceInterface)l.get(i);
431             reevalAssignments(t,po.getName());
432          }
433       } catch (Exception ex) {
434          throw new BaseException(ex);
435       }
436    }
437
438    static void reevalAssignments (SharkTransaction t,String mgrName) throws BaseException {
439       try {
440          List l=SharkEngineManager.getInstance().getInstancePersistenceManager().getAllProcessesForMgr(mgrName,t);
441          List ret=new ArrayList ();
442          for (int i=0; i<l.size(); i++) {
443             ProcessPersistenceInterface po=(ProcessPersistenceInterface)l.get(i);
444             WfProcessInternal proc=SharkUtilities.getProcess(t,po.getId());
445             List acts=proc.getActiveActivities(t);
446             Iterator itActs=acts.iterator();
447             while (itActs.hasNext()) {
448                WfActivityInternal aint=(WfActivityInternal)itActs.next();
449                aint.reevaluateAssignments(t);
450             }
451          }
452       } catch (Exception ex) {
453          throw new BaseException(ex);
454       }
455    }
456
457    static boolean lock(SharkTransaction t, String processId) throws BaseException {
458       LockMaster lm = SharkEngineManager
459          .getInstance()
460          .getLockMaster();
461       try {
462          return (null != lm)? lm.lock(t, processId):true;
463       } catch (RootException e) {
464          throw new BaseException("lock not acquired",e);
465       }
466    }
467
468    static void unlock(SharkTransaction t) throws TransactionException {
469       LockMaster lm = SharkEngineManager
470          .getInstance()
471          .getLockMaster();
472       try {
473          if (null != lm)
474             lm.unlock(t);
475       } catch (RootException e) {
476          throw new TransactionException("lock not acquired",e);
477       }
478    }
479
480    static ParticipantMappingTransaction createParticipantMappingTransaction() throws TransactionException {
481       try {
482          ParticipantMappingManager mm = SharkEngineManager
483             .getInstance()
484             .getParticipantMapPersistenceManager();
485          return (null != mm) ? mm.getParticipantMappingTransaction() : null;
486       }catch(RootException e) {
487          throw new TransactionException(e);
488       }
489    }
490
491    static ApplicationMappingTransaction createApplicationMappingTransaction() throws TransactionException {
492       try {
493          ApplicationMappingManager mm = SharkEngineManager
494             .getInstance()
495             .getApplicationMapPersistenceManager();
496          return (null != mm) ? mm.getApplicationMappingTransaction() : null;
497       }catch(RootException e) {
498          throw new TransactionException(e);
499       }
500    }
501
502    static ScriptMappingTransaction createScriptMappingTransaction() throws TransactionException {
503       try {
504          ScriptMappingManager mm = SharkEngineManager
505             .getInstance()
506             .getScriptMapPersistenceManager();
507          return (null != mm) ? mm.getScriptMappingTransaction() : null;
508       }catch(RootException e) {
509          throw new TransactionException(e);
510       }
511    }
512
513    static void commitMappingTransaction(ParticipantMappingTransaction t) throws BaseException {
514       try {
515          if (null != t) {
516             t.commit();
517          }
518       } catch (TransactionException e) {
519          throw new BaseException(e);
520       }
521    }
522
523    static void rollbackMappingTransaction(ParticipantMappingTransaction t,RootException ex) throws BaseException {
524       SharkEngineManager.getInstance().getCallbackUtilities().error("Rollback of Participant transaction happened.",ex);
525       try {
526          if (null != t) {
527             t.rollback();
528          }
529       } catch (TransactionException e) {
530          throw new BaseException(e);
531       }
532    }
533
534    static void releaseMappingTransaction(ParticipantMappingTransaction t) throws BaseException {
535       try {
536          if (null != t) {
537             t.release();
538          }
539       } catch (TransactionException e) {
540          throw new BaseException(e);
541       }
542    }
543
544    static void commitMappingTransaction(ApplicationMappingTransaction t) throws BaseException {
545       try {
546          if (null != t) {
547             t.commit();
548          }
549       } catch (TransactionException e) {
550          throw new BaseException(e);
551       }
552    }
553
554    static void rollbackMappingTransaction(ApplicationMappingTransaction t,RootException ex) throws BaseException {
555       SharkEngineManager.getInstance().getCallbackUtilities().error("Rollback of ApplicationMapping transaction happened.",ex);
556       try {
557          if (null != t) {
558             t.rollback();
559          }
560       } catch (TransactionException e) {
561          throw new BaseException(e);
562       }
563    }
564
565    static void releaseMappingTransaction(ApplicationMappingTransaction t) throws BaseException {
566       try {
567          if (null != t) {
568             t.release();
569          }
570       } catch (TransactionException e) {
571          throw new BaseException(e);
572       }
573    }
574
575    static void commitMappingTransaction(ScriptMappingTransaction t) throws BaseException {
576       try {
577          if (null != t) {
578             t.commit();
579          }
580       } catch (TransactionException e) {
581          throw new BaseException(e);
582       }
583    }
584
585    static void rollbackMappingTransaction(ScriptMappingTransaction t,RootException ex) throws BaseException {
586       SharkEngineManager.getInstance().getCallbackUtilities().error("Rollback of ScriptMapping transaction happened.",ex);
587       try {
588          if (null != t) {
589             t.rollback();
590          }
591       } catch (TransactionException e) {
592          throw new BaseException(e);
593       }
594    }
595
596    static void releaseMappingTransaction(ScriptMappingTransaction t) throws BaseException {
597       try {
598          if (null != t) {
599             t.release();
600          }
601       } catch (TransactionException e) {
602          throw new BaseException(e);
603       }
604    }
605
606    static UserTransaction createUserTransaction() throws TransactionException {
607       UserTransactionFactory utf = SharkEngineManager
608          .getInstance()
609          .getUserTransactionFactory();
610       return (null != utf)?utf.createTransaction():null;
611    }
612
613    static void commitUserTransaction(UserTransaction t) throws BaseException {
614       try {
615          if (null != t) {
616             t.commit();
617          }
618       } catch (TransactionException e) {
619          throw new BaseException(e);
620       }
621    }
622
623    static void rollbackUserTransaction(UserTransaction t,RootException ex) throws BaseException {
624       SharkEngineManager.getInstance().getCallbackUtilities().error("Rollback of User transaction happened.",ex);
625       try {
626          if (null != t) {
627             t.rollback();
628          }
629       } catch (TransactionException e) {
630          throw new BaseException(e);
631       }
632    }